Text Truncated. Only the first 1MB is shown below. Download the file for the complete contents.
develop
The Apple Technical Journal
CURVES AHEAD:
WORKING WITH
CURVES IN
QUICKDRAW
VALIDATING DATE
AND TIME ENTRY IN
MACAPP
MACINTOSH
DEBUGGING: A
WEIRD JOURNEY
INTO THE BELLY OF
THE BEAST
MACINTOSH HYBRID
APPLICATIONS FOR
A/UX
COPYMASK,
COPYDEEPMASK,
AND LASERWRITER
DRIVER 7.0
GWORLDS AND
NUBUS MEMORY
MACINTOSH Q & A
APPLE II Q & A
Issue 8 Autumn 1991
E D I T O R I A L S T A F F
Editor-in-Cheek Caroline Rose
Spirited Guide Louella Pizzuti
Technical Buckstopper Dave Johnson
Review Board Pete “Luke” Alexander, Chris
Derossi, C. K. Haun, Larry Rosenstein,
Andy Shebanow, and Gregg Williams
Managing Editor Monica Meffert
Contributing Editors Lorraine Anderson,
Geta Carlson, Toni Haskell, Judy Helfand, Rilla Reynolds, and Carol Westberg
Indexer Ira Kleinberg
Manager, Developer Support Systems and
Communications David Krathwohl
A R T & P R O D U C T I O N
Production Manager Hartley Lesser
Art Director Diane Wilcox
Technical Illustration Don Donoughe
Formatting Forbes Mill Press
Printing Wolfer Printing Company, Inc.
Film Preparation Aptos Post, Inc.
Production PrePress Assembly
Photography Sharon Beals, Ralph Portillo,
and Steven C. Johnson
Circulation Management David Wilson
Online Production Cassi Carpenter
This sinuous cover artwork was made possible by quadratic Bézier curves and TrueType, and was created by Rucker-
Huggins (initial studies by Corinne Okada; final arrangements by Cleo Huggins) using Adobe Illustrator 3.0.
d e v e l o p, The Apple Technical
Journal, is a quarterly publication of
the Developer Support Systems and Communications group.
EDITORIAL On-line reading versus on-line reference 2
LETTERS Your letters to us. Keep ’em coming! 4
ARTICLES Curves Ahead: Working With Curves in QuickDraw by Mike Reed and Konstantin Othmer All about quadratic Bézier curves on the Macintosh, including using the curves from TrueType fonts. 7
Validating Date and Time Entry in MacApp by James Plamondon Here’s a new MacApp class that provides robust and flexible entry validation. 28
Macintosh Debugging: A Weird Journey Into the Belly of the Beast by Bo3b Johnson and Fred Huxham This article presents some very useful debugging techniques that every Macintosh developer needs to know about. 43
Macintosh Hybrid Applications for A/UX by John Morley This is an introduction to writing Macintosh applications meant to run under A/UX, explaining the basics and pointing out some potential gotchas. 64
COLUMNS Print Hints From Luke & Zz: CopyMask, CopyDeepMask, and LaserWriter Driver 7.0 by Pete “Luke” Alexander How do you print graphics that use CopyMask and CopyDeepMask with LaserWriter driver 7.0? Read this column to find out. 41
The Veteran Neophyte: Don’t Fence Me In by Dave Johnson Dave waxes philosophical about wirelessness, collaboration, communication, and buffalo heels. 79
Be Our Guest: GWorlds and NuBus Memory by Forrest Tanaka and Paul Snively Taking advantage of NuBus memory for off-screen graphics is tricky. Here are some tips on how to do it in a friendly, compatible way. 95
Q & A Answers to your product development questions.
Macintosh Q & A 82
Apple II Q & A 92
INDEX 99
The Developer CD Series Disc Volume X accompanies this issue of develop. Along with the code described in this issue, it contains all back
issues of develop and other software and documentation that will make your programming life easier and more interesting.
EDITORIALCAROLINE ROSE
Dear Readers,
I’d like to bring up a subject that’s been on my mind lately and a matter of interest to me—and probably to many of you—for quite some time now. It’s the subject of what we called the “paperless office” as far back as the Seventies, when I worked in the same group as Doug Engelbart, inventor of the mouse.
I laughed to myself back then when I’d hear predictions that in ten years or so, manuals would be obsolete. Who needs information in any form other than electronic? Printed manuals persist, but they’re definitely an endangered species. At Apple and many other companies like it, the trend is toward “on-line only” dissemination of information: it uses the technology in zippy ways, it costs less, and it saves trees. Who needs paper, anyway?
I myself don’t care if I ever see most memos, notes, reports, and similar daily jottings in print. I prefer to file the majority of this stuff on-line rather than in my physical file cabinets, which I mostly use to hold rice cakes and pistachio nuts. When I need a reminder of some technical information like the meaning of a parameter or the definition of a word, I like quick on-line access to it as much as the next person. And Balloon Help is great when I’m wondering what a particular command or button is for.
But when I don’t know how to do something at all, or how different pieces fit together, I prefer to read printed documentation. I’m speaking here of the background material that’s needed to get you launched on a particular product in a way that will make you really know what it’s about. (Whether this information is needed at all could be the subject of another editorial.) Call it “concepts” versus “reference.” For me, there’s nothing like reading about concepts in a real book when and where I want. The image that comes to mind is “curling up in front of a fire.” I’d much sooner do that with a good novel than a technical manual, but still I like to pick a place and time away from my computer to take in the concepts. It’s quieter and more comfortable, especially on my eyes, and it’s a more pleasing visual and tactile experience. I learn more that way. Later, I might want to look up some conceptual material on-line, but for first-time reading and learning, I want hard copy.
At the last company I worked for we surveyed a lot of developers on this, and most of them seemed to agree. We decided to divide our technical documentation along those exact lines: concepts versus reference; concepts would always be available as a printed manual while reference would be on-line only (or primarily, at least).
This all ties in with the fact that Apple Associates and Partners no longer receive a printed copy of develop as part of their regular mailing; they have to subscribe to develop to receive it in print. The mailing has been simplified to be just a CD-ROM disc and a 16-page publication in newspaper format that points to things on the disc. Those developers who don’t want a lot of paper don’t have to deal with it; those who do can order it. So Associates and Partners will cast their vote for paper develop by subscribing to it. (Letters from all of you expressing your opinions—especially when they agree with mine—are of course more than welcome.)
Speaking of electronic media, those of you who were receiving develop with its CD-ROM disc bound into it will notice that the disc corresponding to this issue has been packaged separately in its own case (made of partially recycled fiberboard and plastic). This should put a stop to the problem of mangled discs. Also, the disc is no longer the Developer Essentials disc, but the Developer CD Series disc, the same disc that Apple Associates and Partners receive. We hope this will make life easier for us and less confusing for you (not to mention that you’ll get more goodies on the disc than before!).
I’ll end with a vaguely related trivia question: What word was used instead of “click” to describe the action of pressing a button on that first mouse? If you’ve got any good trivia questions of your own, send them along to us. We need all the help we can get.
Caroline Rose
Editor
LETTERS
THREADS PACKAGING
I’m impressed with threads and futures and I think they’ll be of real use to me in a commercial product I’m working on. I have a simple problem. I don’t think we can ship your INIT with our application. Doing so constitutes an unnecessary invitation to support hassles (as well as a just plain unaesthetic package, in my opinion). Is there any chance that you could repackage the current threads and futures stuff as straight libraries (in THINK C form, please)?
—Richard Reich
The latest version of threads and futures, which is on this issue’s CD, has been augmented so that you have your choice of how to package the code. Just use the INIT as is, or copy the code resources into your application. Let me know if you need any more help. My number is (408)974-0355.
—Michael Gough
THREADS IN A BLACK BOX
I was really pleased to see the article on threads in Issue 6 of develop. There have been several instances in my programming experience on the Macintosh when I had some long involved processing that was not easily restructured to pass control to the interface or to other applications. The Threads Package seems like the best way to handle this problem that we are likely to have without major changes in the Macintosh OS.
However, I was disappointed to discover that Semaphore, one of the examples from the CD, crashes. If you click before the program is finished, it exits normally, but if you let it run its course, it crashes after it’s done beeping. I hope that a corrected version of the Threads Package will be available on a future develop CD.
If the source code for this package had been provided on the disc, I would at least have a chance of understanding the source of the bug and correcting it. Instead I must rely on the possibility that a corrected version of the object code will be provided with a future issue of develop. We can count on Apple to provide updates for object libraries supplied with MPW; hence we have no need for the source. Can we rely on the same level of support for object libraries without source distributed on develop CDs?
I’ve seen develop evolve from a journal with good articles on programming techniques into a journal with articles that were basically blurbs for source code, and now into a journal with articles that are blurbs for black boxes provided on the CD. I still think develop is an extremely useful resource for Macintosh programmers. However, I urge you to try to include source code when you possibly can.
At any rate I am looking forward to seeing a corrected version of the Threads Package in a future issue of develop—I intend to give it a try even if it is a black box!
—Dennis C. De Mars
You’re right, the Semaphore example crashes, and it is a bug in the Threads Package. I guess I always clicked out early during the final testing. Issue 7 has a follow-up article to Threads that includes an updated (and fixed) Threads Package.
To address your concern about develop heading toward “black boxiness”: The Threads Package is the only develop article ever that hasn’t included source code. We debated for a long time whether that was OK, and many people expressed the same concerns you did. We decided that Threads was unique enough and useful enough to justify it. The reaction has been extremely positive, so I think we did the right thing.
I assure you that we won’t make a habit of featuring black boxes, and that as long as Michael Gough keeps supporting Threads, the latest CD will contain the latest version. Threads is not an official Apple product, though, so use it in your application at your own risk. It’s possible that we will be able to publish the source code someday.
Thank you for taking the time to write! People’s comments are the best barometer we have for how we’re doing.
—Dave Johnson
CD SETUP (AND MORE!) ON CD
How about including on the Developer Essentials CD-ROM a copy of the latest version of the CD Setup disc that comes with the AppleCD SC drive? It would be a convenient way to get a current version of the AppleCD SC software, and a lot of people who are browsing your CD have an AppleCD SC anyway.
—Kazimir C. Stusinski
The latest version of the CD Setup disc is on this issue’s CD. Note that it’s now the “Developer CD Series” disc, the same disc that Apple Associates and Partners receive. The contents of Developer Essentials was only a subset of the Developer CD Series disc; now you can have it all!
—Caroline Rose EVASIVE SNIPPETS
The Snippets section of develop always has such neat-sounding code fragments in it . . . if only I could find them! I always peruse the Developer CD Series disc that arrives with each issue of develop, but many of the snippets can’t be found, either by my old-fashioned hand searching or by using the HyperCard® stack that, hopefully, really does have a complete index of the contents.
It’s safe to say that it seems that most can’t be found. Assuming they are there—somewhere—I’d like to suggest that the code you list in the Snippets section be included in the develop folder. Even a directory or stack in that folder that would point me to them would be a terrific savings in time. Keep up the good work!
—Chris Gibson
Snippets have had a rough time. They didn’t make it onto the Issue 6 CD at all. And, although they were on the Issue 7 CD, they were not mentioned in the Contents Catalog stack on the Developer CD Series disc. They can be found with the DTS sample code. That seems the most logical place for them, since they’re not strictly a develop thing: they come from DTS (Developer Technical Support); we just describe them (and we’ve decided to stop that—they’re now described in a text file in with the snippets). Sorry for the confusion!
—Dave Johnson
ONE UGLY DUDE
I just wanted to comment that I was totally shocked when I saw Harry Chesley’s picture in develop this month.
“This is one ugly dude,” I thought. Perhaps his picture was sabotaged. Or maybe he really is a Vulcan with three Adam’s apples!
—Dan Wood
Actually, that picture wasn’t supposed to be printed at all. It’s top secret, the result of an internal Apple project in the area of desktop bioengineering.
But now that the cat’s out of the bag, I guess I can mention that we’re expecting to ship the product second quarter next year. It attaches to the SCSI port of the Macintosh. You stick one of your fingers in a hole in the front, and it modifies your DNA. The actual physiological changes take about a week to materialize.
—Harry Chesley
P.S. The three Adam’s apples are a bug, which we’re planning to fix in the next rev. WHERE'S LOUELLA, REALLY?
I sent mail to your predecessor, Louella, at louella@applelink.apple.com, but your system denied knowing about her. Any help you could give me in addressing e-mail to her would be very much appreciated.
—An Admirer
In Issue 7, I joked that Louella had retired to raise flowers in Holland. Well, I was close: she has left Apple to paint and write until her money runs out. We’ll miss her terribly but will remember her always as our “Spirited Guide.” She’ll be living wherever the living is easy (and cheap), but letters will always get to her through this address: 932 Rosette Court, Sunnyvale, CA 94086. Sorry, she will no longer be electronically plugged in.
—Caroline Rose
UPDATES TO CODE ON THE DISC
On the Developer CD Series disc, the code that corresponds to articles in develop is kept up to date wherever possible. Bugs that are reported are fixed, changes are made to maintain compatibility, and so on. The latest CD always contains the most up-to-date versions of the code for all issues of develop, so if you’re going to use any code, get it from the most recent CD you have—even if the article is in a past issue.
A notable change on this disc is that the QuickTime example from Issue 7 has been updated to work with the beta release of QuickTime, and has a couple of new features as well. Also, we’ve included the beta QuickTime extension, so you can try the samples immediately. (Remember, this is prerelease software that cannot be distributed or included with shipping applications.)
Another change we’ve made, to be sure we give you the latest possible information, is to include descriptions of code “snippets” on the disc itself rather than describe them in develop. The Snippets folder (which is in with the DTS sample code) now includes text files that describe all of the snippets. The snippets are batched by date of release, so you can easily tell what’s new.
CURVES AHEAD: WORKING WITH CURVES IN QUICKDRAW
MIKE REED AND
KONSTANTIN OTHMER
Imagine being able to build into your application the capability to draw freehand curves. Imagine being able to save these curves so that they can be loaded into other programs like MacDraw or printed using the LaserWriter. And imagine being given the key to an abundant supply of previously defined curves to play with. Imagine no more . . . this article reveals all.
QuickDraw is a heck of a fine drawing engine for the Macintosh, but it does have its limitations. In particular, it supports a limited set of geometric primitives for drawing: lines, rectangles, rounded-corner rectangles, ovals, arcs, and polygons (see Figure 1). If you want your application to provide the capability of drawing contours consisting of curves and straight lines, you’re out of luck.
Sure, you can use the arc primitive to draw a curve, but if you want to connect the curve to anything, you’ve got a problem. An arc represents a segment of an ellipse and is specified by a bounding rectangle (defining the ellipse) and start and stop angles (see Figure 2). Because an arc is not specified by starting and ending points, it’s hard to know the exact points where QuickDraw will begin and end drawing the arc. Thus, the arc does not lend itself to being combined with other arcs or lines.
A more useful curve primitive would be one that describes its start and end positions as points. The quadratic Bézier is just such a curve. Applications such as MacDraw® use this type of curve to allow the drawing of freehand curves, and the Macintosh itself uses this type of curve in an internal procedure to describe TrueType fonts.
In this article we give you the lowdown on the quadratic Bézier. We show the coding and the data structures used by programs like MacDraw to draw this kind of curve, and we show how your application can interchange data about this kind of curve with MacDraw and with devices equipped with a PostScript® interpreter. And since the quadratic Bézier happens to be the same curve that TrueType uses
(in combination with other shapes) to draw outline fonts, we show how to extract curve data from TrueType fonts.
Figure 1
QuickDraw’s Geometric Primitives
DRAWING CURVES AND PATHS
The quadratic Bézier has a couple of properties that make it useful as a basis for drawing curves in QuickDraw. First, it can be rotated easily by changing just the starting, ending, and middle points and not the underlying equation itself. Second, it can easily be subdivided into any number of shorter curves that become flatter and flatter, until in effect it can be drawn with a series of straight lines. Indeed, the basic technique for drawing a curve using the existing QuickDraw primitives is by subdividing the curve into a series of line segments. If you’re interested in the mathematics behind this, see “Parametric Equations, Anyone?”
This section begins by showing sample C code that implements the subdivision algorithm that produces a curve. We then move on to consider how to produce a
Figure 2
How an Arc Is Specified in QuickDraw
combination of curves and straight lines, known in the lingo as a path. Then we talk about how to combine paths to produce shapes. Note that for a curve, as for every geometric primitive in QuickDraw, you always have two options: you can either frame it or fill it. We show you how to do the framing; you can do the filling using the call FillPoly or PaintPoly.
FRAMING A CURVE
The code that implements the subdivision algorithm to produce a curve takes a value for the number of times the curve should be subdivided before it’s drawn as straight lines. This number can be dynamically computed based on the size of the curve and the quality-versus-speed trade-off the application wants to make. The code uses fixed-point coordinates to maintain high precision during the subdivisions.
To begin, let’s define a few macros to help us use fixed-point coordinates in an integer-based graphics system.
#define FR(x) ((x) + 0x8000 >> 16)
#define ff(x) ((long)(x) << 16)
#define fmoveto(x,y) MoveTo(FR(x), FR(y))
#define flineto(x,y) LineTo(FR(x), FR(y))
#define AVE(a,b) (((a) + (b)) / 2)
FR The same as FixRound: takes a Fixed and makes it a short.
ff The reverse of FixRound: takes a short and promotes it to a Fixed.
fmoveto The same as MoveTo, but takes Fixed coordinates.
flineto The same as LineTo, but takes Fixed coordinates.
AVE Averages two numbers, either Fixed, short, or long.
PARAMETRIC EQUATIONS, ANYONE?
Though you can draw curves without understanding the mathematics behind the operation, some people find this kind of thing interesting. This explanation is for those people (you know who you are).
A quadratic Bézier (or parabola) can be defined by the parametric equation
f(t) = a(1 – t)2 + 2bt(1 – t) + ct2
where t is a scalar and a, b, and c are points.
This parametric formulation has the advantage of being rotationally independent: since t is the independent variable, and not x or y, there is no bias for curves that are symmetric about the x- or y-axis. Thus, to rotate the curve, you only need to rotate a, b, and c into their new positions, while the equation for the curve stays the same.
To better understand the equation, take a look at its geometric representation in Figure 3. You’ll note there that as the curve is drawn from point a to point c, t varies from 0 to 1. The curve at a is tangential to the line ab, and the curve at c is tangential to the line bc. Its maximum displacement from the line that could be drawn from a to c is reached at point q, where t is 0.5. In addition, the curve at q is parallel to the (imagined) line ac.
Perhaps the most useful property of the curve in this form is the easy way it can be decomposed into a pair of smaller curves, each of the same form. This is called subdivision and is the basis for drawing curves in QuickDraw.
Suppose we subdivide the curve at point q, as shown in Figure 4. The point q is
q = f(0.5) = (a + 2b + c) / 4
The tangent (that is, the first derivative) of the curve at q is parallel to the line ac. f'(t) = –2a(1 – t) + 2b(1 – 2t) + 2ct
f'(0.5) = c – a
The line from the point b' = (a + b) / 2 to q is tangential to the curve at q.
q – b' =
(a + 2b + c) / 4 – (a + b) / 2 =
(a + 2b + c – 2a – 2b) / 4 =
(c – a) / 4
By symmetry, the same holds for b'' = (b + c) / 2.
Thus, the formulas for the two curves that make up the left and right halves of the original curve are as follows:
Left: a' = a
b' = (a + b) / 2
c' = (a + 2b + c) / 4
Right: a'' = (a + 2b + c) / 4
b'' = (b + c) / 2
c'' = c
The equations for the new points are especially nice, since the arithmetic can be performed with only shifts and adds, making it very efficient.
Notice in Figure 4 that each of the resulting smaller curves is flatter than the original curve, by a factor of 4. This means that the distance from the midpoint of the curve to the midpoint of the straight line drawn from the start point to the endpoint is reduced by 4. Thus, if the curve is subdivided enough times, drawing the curve will be equivalent to drawing a line from the start point to the endpoint for each of the little curves. This is the basis for drawing the curve in QuickDraw.
Figure 3
Geometric Representation of Our Bézier
Figure 4
Our Bézier, Subdivided
To represent fixed-point coordinates, we define a struct called point. Note that this is similar to QuickDraw’s Point, but uses Fixed numbers instead of integers.
typedef struct {
Fixed x;
Fixed y;
} point;
To represent a curve, we need three points: a start point, a control point, and an endpoint. (These correspond to a, b, and c in Figure 3.)
typedef struct {
point start;
point control;
point end;
} curve;
The function FrameCurve (below) draws a quadratic Bézier using subdivision. If the level for the FrameCurve routine is 0, a LineTo (using flineto) operation is performed; otherwise, the curve is subdivided and FrameCurve is called recursively, once for the left half of the curve and once for the right. FrameCurve assumes the caller has already called fmoveto on the start point of the curve. The second routine, ExampleCurve, calls FrameCurve requesting four levels of subdividing. Thus, the final curve consists of 2^4, or 16, lines. It’s shown in Figure 5.
FRAMING A PATHDrawing contours such as font outlines requires drawing a combination of straight lines and curves. Such a combination is known as a path. A path is defined by the following data structure:
typedef struct {
long vectors; /* The number of points in the path. */
long controlBits[anyNumber];
point vector[anyNumber]; /* The points. */
} path;
A path is similar to a polygon except that it has a set of control bits that determine whether each point is on or off the curve. There’s one control bit for each point, beginning with the most significant bit for point 0. If the bit is set, the corresponding point is an off-curve point and therefore the control point for a curve. If the bit is clear, the corresponding point is an on-curve point and therefore an endpoint for either a line segment or a curve segment. Two consecutive on-curve points form a straight line.
Here’s a routine that takes an index and the control bits and returns TRUE (nonzero) if the point is on the curve:
Boolean OnCurve(long *bits, long index)
{
bits += index >> 5; /* Skip to the appropriate long. */
index &= 31; /* Mask to get index into current long. */
return (*bits & (0x80000000 >> index)) == 0;
}
Two consecutive off-curve points imply an on-curve point at their midpoint, as shown in Figure 6. This path consists of two curve segments. The first is defined by a, b, (b + c) / 2 and the second by (b + c) / 2, c, d.
This ability to store a series of off-curve points allows a path to describe an arbitrarily complex shape without having to store unneeded intermediate points. However, this is just a storage nicety. When we draw the path, we need it broken down into a series
Figure 6
On-Curve Point Implied by Two Off-Curve Points
of line and curve segments. This is done with an iterator function called NextPathSegment. It’s called continuously, each time filling a record that is either a line segment or a curve segment, until it returns FALSE.
typedef struct {
int isLine;
curve c;
/* Private. */
long index;
long ep;
long *bits;
point *p;
} pathWalker;
void InitPathWalker(pathWalker *w, path *aPath)
{
w->index = 0;
w->ep = aPath->vectors - 1;
w->bits = aPath->controlBits;
/* Skip past the control bits to point to the first point. */
/* The first segment is special, since it calls fmoveto. */
if (NextPathSegment(&walker))
{ fmoveto(walker.c.start.x, walker.c.start.y);
if (walker.isLine)
flineto(walker.c.end.x, walker.c.end.y);
else
FrameCurve(&walker.c, kCurveLimit);
}
/* Keep looping until we run out of segments. */
while (NextPathSegment(&walker))
if (walker.isLine)
flineto(walker.c.end.x, walker.c.end.y);
else
FrameCurve(&walker.c, kCurveLimit);
/* Return the next path, used if this path is one of several within
* a series of paths. */
return NextPath(cont);
}
Now we can draw the path shown in Figure 6 that demonstrates consecutive off-curve points.
void ExamplePath()
{
long myPath[] = {
5, /* Five points. */
0x60000000, /* The second and third are off-curve points. */
0,0,ff(10),0,ff(20),ff(10),ff(20),ff(20),0,ff(20) /* x,y data */
};
FramePath((path *)myPath);
}
FRAMING A SHAPE MADE OF SEVERAL PATHS
To describe a shape that contains several disjoint paths (such as an outline letter o), we use a simple data structure that’s just a composite of several path structures:
typedef struct{
long contours;
path contour[anyNumber];
} paths;
Drawing such a shape (called in the vernacular a paths) is straightforward:
void FramePaths(paths *aPath)
{
long ctr = aPath->contours;
path *cont = aPath->contour;
while (ctr--)
cont = FramePath(cont);
}
The following code draws the paths shown in Figure 7.
Now that you know how to give your application the capability to draw all sorts of curved shapes on the screen or on a QuickDraw printer, you might wonder whether you can cut and paste these shapes into other applications or send them to a
Figure 7
A Shape Made of Several Paths
PostScript printer. The answer is yes, thanks to picture comments. Picture comments encapsulate non-QuickDraw graphics data that other “smarter-than-QuickDraw” applications can interpret.
Fortunately, there’s a picture comment that takes quadratic Bézier information directly: PolySmooth. When this comment is encountered in a PICT it indicates that the endpoints of the following lines are control points of a quadratic Bézier. Unfortunately, the comment assumes that all the control points lie off the curve. This is a major drawback of the PolySmooth comment and forces us to break a path down into curves and lines, rather than allowing us to put an entire path in at once.
When a picture interpreter (such as the LaserWriter driver) sees a PolySmooth picture comment, it interprets the following points (put in the picture with a LineTo opcode) as off-curve control points. Since DrawPicture ignores picture comments completely, the clipping rectangle is set to empty so that no drawing will occur. The picture interpreter now has the control points and can render the curve however it sees fit.
To save a path in a picture, we start with the PolyBegin picture comment. This comment indicates that a special polygon follows. If the path is closed, we add the picPlyClo comment. Then we set the clipping to empty so that DrawPicture will not
render the following data. Next we add the PolySmooth comment, followed by the control points.
When the whole polygon is in the picture, we restore the clipping to its previous state and add the PolyIgnore picture comment. Anyone reading picture comments will know to ignore the following QuickDraw polygon. DrawPicture, which ignores all picture comments and skips over the smooth polygon since the lines are all clipped out, will draw the polygon just as it should.
Thus, we have something like the following (where an asterisk indicates a picture comment):
Save the current clip
*PolyBegin
Set the clip to the empty rectangle to turn off drawing
*PolySmooth
Record the PostScript version of the curves (just the control points)
*PolyIgnore
Restore the original clip to turn drawing back on
Record the QuickDraw version of the curves (subdivided into short lines)
*PolyEnd
Since the PolySmooth picture comment allows only off-curve points, it’s necessary to break the path down into segments. This is done by the AddPathsToPict routine, which calls AddSegmentToPict for each path fragment (either a single quadratic Bézier or a line). AddSegmentToPict copies two sets of points into the PICT, one that contains the actual control points of the curve or line segment (for PostScript printing or pasting into MacDraw) and another that is the QuickDraw rendering of the curve or line.
In AddSegmentToPict (below), cur is the current segment to be added; isLine is a Boolean identifying whether the segment is a curve or a line segment; and delta specifies an amount to offset the data when recording the PostScript version, to account for the difference between PostScript’s centered pen and QuickDraw’s upper left pen.
void AddSegmentToPict(curve *cur, point *delta, int isLine)
{
/* Real programs check errors. */
Handle verbHdl = NewHandle(1);
RgnHandle origClip = NewRgn();
Rect emptyRect = {0, 0, 0, 0};
**verbHdl = kPolyFrame;
GetClip(origClip);
PicComment(POLYBEGIN, 0, 0);
ClipRect(&emptyRect); /* This turns drawing off. */
SetClip(origClip); /* This turns drawing back on. */
/* Record the lines for QuickDraw. */
fmoveto(cur->start.x, cur->start.y);
if (isLine)
flineto(cur->end.x, cur->end.y);
else
FrameCurve(cur, kCurveLimit);
PicComment(POLYEND, 0, 0);
DisposeRgn(origClip);
DisposHandle(verbHdl);
}
AddPathsToPict is relatively simple. It walks through each path, and each segment within each path, and records the segments by calling AddSegmentToPict.
AddPathsToPict(paths *myPaths)
{
point penDelta;
long i;
path *cont;
/* Compute half the pen's thickness as a delta, since PostScript's
* pen is centered and QuickDraw's hangs to the right and down. */
A word about rounding: We’ve kept all our data in Fixed, even during the subdivision process, up until calling LineTo; still, when we record the data into a PICT, we’re forced to throw away information since the PICT records only integer coordinates. The upshot of this is that a given series of paths may draw much better in your application than when it’s been put into a PICT and pasted into another application.
EXTRACTING CURVES FROM TRUETYPE
Because TrueType uses the quadratic Bézier as its curve primitive, as mentioned earlier, the outlines in a TrueType font represent a rich source of curve data for programmers. In fact, a program demonstrated at Apple’s Worldwide Developers Conference in May of this year uses TrueType fonts as a basis for turning text typed by the user into outlines that can be rotated, filled, stretched and shrunk, and transformed in other amusing ways. All it takes to produce such a program is to convert TrueType data from its native storage structure into a paths data structure. We show you how to do that here, and then discuss the sample program you’ll find on the Developer CD Series disc that draws outlines extracted from TrueType fonts.
CONVERTING THE DATA
For space reasons, the data for TrueType outlines is not stored in a paths data structure but instead is compressed as byte deltas. Code provided on this issue’s Developer CD Series disc fills out a glyph outline data structure given a TrueType font and a glyph ID. The glyph outline data structure looks like this:
typedef struct {
long contourCount;
long pointCount;
point origin;
point advance;
short **endPoints; /* [contourCount] */
Byte **onCurve; /* [pointCount] */
Fixed **x; /* [pointCount] */
Fixed **y; /* [pointCount] */
} GlyphOutline;
A glyph outline is a bit less compact than a paths data structure, but contains enough information to be converted into one. One difference from the paths data structure is that in a path, if a control bit is set, the point is treated as an off-curve point. In a glyph outline, if the onCurve byte is set, the point is treated as an on-curve point. Another difference is that in a glyph outline, the points for all the contours are stored contiguously, rather than separated into discrete path structures.
The utility function PackControlBits takes an array of bytes, each representing a point, and packs them into a bit array, suitable for a path. It then returns a pointer to the long after the last control long.
long *PackControlBits(long *p, Byte *onCurve, long count)
{
unsigned long mask = 0x80000000;
*p = 0;
while (count--)
{ if (!mask)
{ mask = 0x80000000;
*++p = 0;
}
if (!*onCurve++)
*p |= mask;
mask >>= 1;
}
return p + 1;
}
The function OutlineToPaths takes a glyph outline and returns a pointer to a path that represents the outline. NewPtr is called, so when the application has finished using the path it should call DisposePtr.
paths *OutlineToPaths(GlyphOutline *out)
{
long size, *p, *origP;
/* First compute how big the resulting path will be. */
ABOUT OUR SAMPLE APPLICATION.i(.QD Curves application;
The sample application QD Curves on the Developer CD Series disc uses paths to draw the outlines of TrueType text. It can put the outlines onto the Clipboard so that they can be pasted into another application for editing or printing. In addition, the application uses some of the other TrueType access functions to build variable-length font and style menus and display information about a font, such as its version number, copyright notice, and trademark (see Figure 8).
To display a path, the application determines how large the path currently is and scales it to fill the window. The utility functions OffsetPaths, ScalePaths, and GetPathsBounds are used in positioning and scaling paths.
/* The next path follows the end of the current path. */
cont = (path *)coord;
}
}
Note that what is returned is the bounds for the control points of the paths, not necessarily the bounds of the actual paths being drawn (see Figure 9). That requires a slightly more complex, though useful, function, which we leave to you as an exercise. (Hint: Find the x and y extrema for the curve. To do this, find the local extrema in t by setting the derivative of the equation in x or y equal to 0, and solve for t.)
Figure 9
Bounds of the Control Points Versus Bounds of the Curve
As part of its display options, the application will also mark the on-curve points in the paths.
for (ptIndex = 0; ptIndex < cont->vectors; ptIndex++)
{ r.left = FR(*coord++) - 2;
r.top = FR(*coord++) - 2;
r.right = r.left + 5;
r.bottom = r.top + 5;
if (OnCurve(bits, ptIndex))
PaintOval(&r);
#ifdef mark_off_curve
else
FrameOval(&r);
#endif
}
cont = (path *)coord;
}
}
This function to mark the control points of a path is a good framework for adding curve editing. We leave that to you also, and suggest that besides simple point-by-point direct mouse editing, you consider providing the capability to do the following:
• do direct curve editing by hit-testing the curve itself instead of just its control points
• select groups of points/segments to move at once, similar to selecting multiple icons in the Finder
• do constrain-based editing, where tangent continuity is maintained between adjacent segments
• interpolate changes to a set of key points across the rest of the path, allowing, for instance, creation of a bold character by simply moving a few points on the stems and then smoothing out the rest of the outlines
NOW IT’S UP TO YOU
This article has given you the tools to do some fancy work with curves in your applications. We’ve given you routines for drawing curves and paths using QuickDraw, discussed how to save these in PICTs so that they can be loaded into other programs like MacDraw or printed using the LaserWriter, and shown how to extract paths from TrueType fonts, giving you an abundant supply of path data. Now it’s up to you to play off this knowledge by adding curve editing, text rotation, and other means of transforming your new freehand curves.
VALIDATING DATE AND TIME ENTRY IN MACAPP
JAMES PLAMONDON
MacApp’s TEditText class checks strings entered by the user, displaying an error message when an invalid string is encountered. This article shows how TEditText’s validation and error notification schemes can be made more flexible, and demonstrates this flexibility in TEditText subclasses for the entry of dates and times. You can try out these classes in the sample program that’s on the Developer CD Series disc.
My favorite high school teacher, Mrs. Whalen, had a sign under the wall clock in her classroom that read “Time passes—but will you?” Back when I was in the Class of ’78, there were many times I wished that I could set the clock back (during a tough quiz) or forward (on a warm afternoon). Although I can’t offer any such hope to the Class of ’91, I can at least provide MacApp developers with classes that make the entry of dates and times as easy as I ever dreamed.
I wrote these classes during some recent work on a MacApp application that involved the entry and validation of dates and times. After considering and rejecting all sorts of controls—controls that looked like little monthly calendars, 24-hour clocks, and so on—I settled on simple editable text boxes. I thought that with these boxes, those pesky localization issues that plagued the other designs wouldn’t be a problem, because I could use the Macintosh Script Manager to handle the different date and time formats described by the international resources in the operating system. I also figured that if I used MacApp’s TEditText class, writing editable text boxes for date and time entry would be trivial. An override here, a little data there, and voilà—done. It wasn’t the first time I’ve been wrong.
But to understand TEditText’s flaws, first you have to know how it works.
TEDITTEXT REVEALED
TEditText is a TControl subclass. It encapsulates the Toolbox’s TextEdit routines.
A TEditText view is to one of MacApp’s TDialogViews what an editText item is to one
of the Dialog Manager’s dialogs: it allows the user to enter strings into a box in a dialog box. In addition, TEditText extends the functionality of editable text items to include the notion of validation. If an invalid string is entered into a TEditText view, an alert is displayed, notifying the user of the problem.
The validation process implemented by TEditText centers on its Validate method. In TEditText, a valid string is any string that’s not longer than the maximum allowed length, which is specified by the application’s author. If the string is valid, the Validate method returns the constant value kValidValue; otherwise—that is, if the string is too long—it returns the error code kTooManyCharacters. TNumberText, a subclass of TEditText that handles the entry and validation of integer numbers, can return additional error codes—kValueTooSmall, kValueTooLarge, or kNonNumericCharacters.
The only place Validate is ever called in MacApp is from the TDialogView method DeselectCurrentEditText. If Validate returns a value other than kValidValue, that value is assumed (in a call to TDialogView.CantDeselect) to be an index into a string list resource called kInvalidValueReasons. It’s expected that the string at that index will describe the error encountered. This string is then displayed in an error alert that tells the user why the string entered is invalid. Figure 1 shows the alert displayed when the user types too many characters into a TEditText view.
Figure 1
MacApp’s Validation Error Alert
My dad used to say “Whenever a guy’s telling you what he’s gonna do for you, start worrying about what he’s gonna do to you.” It wasn’t long before I realized that TEditText was like that. I had hoped that it would be easy to extend the checking done in TEditText.Validate to include checking for a valid date or time, but it wasn’t. To add this kind of checking, I was going to have to rewrite Validate from scratch— just the kind of thing object-oriented programming is supposed to prevent.
DON’T FIX WHAT AIN’T BROKE
When in the course of application programming it becomes necessary to replace a mechanism written by the MacApp engineers, one should declare the causes that impel this decision. I hold these truths to be self-evident:
1. That the reuse of existing code is preferable to the addition of new code.
2. That the addition of new code is preferable to the alteration of existing code.
3. That the alteration of existing code is preferable to missing a deadline.
MacApp’s approach to text validation fails to meet a number of these criteria. First, it assumes that new error strings will simply be added to the STR# resource called kInvalidValueReasons, with new error codes indexing the added strings. However, this won’t work: TDialogView.CantDeselect uses a constant, kNoOfDefaultReasons, to indicate the number of strings in this resource. It can only be changed by altering and recompiling MacApp—a violation of self-evident Truth #2.
Also, the error-code-equals-string-index scheme can be a problem when one combines existing class libraries; two different TEditText subclasses, written independently, may use the same error codes (and string indices) to indicate different problems. Resolving this conflict would probably require changing and recompiling at least one of the conflicting classes.
Further, the use of error strings can cause problems during localization since not all languages can stick an arbitrary string into a sentence and have the result make any sense. Static error strings also give little context—they may not be able to display the invalid string, or a valid example string, to help the user figure out what went wrong.
For all of these reasons, MacApp’s use of a single error string list—with Validate’s result being used as an index into this list—seems inappropriate. Each class should instead build its own error strings in any manner it sees fit, using its own string lists as necessary.
That’s not all. The error alert displayed when invalid strings are encountered has only one button. But what if two or more alternative actions can be taken in response to the entry of an invalid string?
Consider the following validation case (which has nothing to do with dates or times). Assume that the user needs to enter the name of a category—like Work, School, or Personal—into an editable text box. If the string the user enters matches the name of an existing category (for example, “Work”), the string is valid; otherwise—for example, if the user types “Wirk”—the string is invalid.
In addition, we want to allow the user to add new categories to the list by entering them into the editable text box. To do this, we must distinguish those entries that are simply mistyped (like “Wirk”) from those intended to become new category names (like “School” or “Personal”). In effect, we need to present the user with a two-button dialog box like that in Figure 2.
Figure 2
Two-Option Validation Error Alert
Unlike the default MacApp validation alert, which has only one button, the dialog box in Figure 2 allows the user to decide whether the entered string—“Personal,” in this case—is valid or invalid.
TVALIDTEXT: THE UNAUTHORIZED BIOGRAPHY
So to extend validation to dates and times, I decided to write two new classes, TDateEditText and TTimeEditText. After writing these classes, I realized that they had so much validation code in common that it made sense to put this code in a common superclass. I called this superclass TValidText.
TValidText is a pretty simple extension to TEditText. It adds three notions to TEditText—strictness, required value, and an invalid entry alert ID. It also significantly enhances the text validation process.
TValidText is an example of an “abstract class”—a class that’s never expected to be instantiated directly. It exists only to factor out the code that’s expected to be common to its subclasses. All of TValidText’s subclasses will simply inherit its validation and error reporting code, while overriding a few methods to implement their own specific validation tests and error messages.
The class declaration for TValidText is as follows:
WHAT ABOUT MACAPP 3.0?
MacApp is an evolving system, just like the Macintosh itself. With the coming of System 7, a new and more powerful version of MacApp is in the works: MacApp 3.0.
Totally rewritten in C++, this new version of MacApp is still in development; however, an early version, MacApp 3.0b1, is available to Macintosh developers on the Essentials•Tools•Objects CD #5.
MacApp 3.0 will offer a lot of new features, most of them directed toward support for System 7. A discussion of most of these features is far beyond the scope of this article. With regard to text validation, MacApp 3.0’s display of validation error alerts is much improved.
In MacApp 3.0, the TargetValidationFailed method has been added to TEvtHandler to allow each class to handle validation errors in a class-specific manner. An override of TargetValidationFailed in TDialogTEView calls another override of the same method in TEditText, which displays the error alert and restores the TEditText’s previous contents. Thus the validation error alert is posed by TEditText, not by TDialogView, as was the case in MacApp 2.0. That’s a big improvement.
Unfortunately, the nature of TEditText’s Validate routine remains unchanged in MacApp 3.0. If your application requires more flexible validation than that provided by MacApp, you may still need to use some of the techniques described in this article.
TValidText = OBJECT(TEditText)
fStrict: BOOLEAN;
fRequired: BOOLEAN;
fAlertID: INTEGER;
•
• See the Developer CD Series disc for method declarations.
•
END; {TValidText}
TValidText’s fStrict field, a Boolean variable, determines whether or not strict checking will be used when validating. This field exists here because both the date and time classes needed the concept. TValidText itself doesn’t use fStrict, except to get and set its value. It might be more general to implement it as a scalar (maybe a signed byte) to provide multiple strictness levels. We’ll look at strictness again in the discussion of the date and time classes later in this article.
The fRequired field answers the question of whether an empty string is valid or not. As far as TValidText is concerned, if fRequired is true, an empty string is invalid; otherwise, it’s valid. TValidText’s subclasses may add additional conditions to the notion of validity by overriding the method IsValid and calling the inherited version. Both the date and time editing classes do this, as we’ll see later.
The fAlertID field contains the resource ID of the alert to be displayed when the current text doesn’t pass validation. It may contain the value phInvalidValue (defined
in UDialog), or the resource ID of any other ALRT resource. It would be easy to override the routines involved to display a MacApp dialog box rather than a Toolbox alert, in which case fAlertID could be the ID of the appropriate view resource.
THE NATURE OF VALIDITY
The TValidText declaration introduces a new method, IsValid:
FUNCTION TValidText.IsValid(
VAR theText: Str255;
VAR whyNot: INTEGER)
:BOOLEAN;
In addition to returning a Boolean indicating the validity of the given string, IsValid returns in whyNot an indication of why the string is invalid (or the value noErr, if it’s valid). This is very similar in functionality to TEditText’s Validate routine, with one major difference: the string being validated is passed in as an argument. Where TEditText.Validate assumes that it’s supposed to validate the string currently being edited, TValidText.IsValid can be used to test arbitrary strings for validity.
I overrode the Validate method in TValidText to make it a flow-of-control method. It validates the current string and displays the error alert when necessary, as follows:
FUNCTION TValidText.Validate:LONGINT; OVERRIDE;
VAR
parentResult: LONGINT;
theText: Str255;
whyNot: INTEGER;
BEGIN
{Make sure the current text passes the superclass's validation.}
parentResult := INHERITED Validate;
IF (parentResult <> kValidValue)
THEN
Validate := parentResult
ELSE
BEGIN
GetText(theText);
IF IsValid(theText, whyNot)
THEN
Validate := HandleValidText(theText)
ELSE
Validate := HandleInvalidText(theText, whyNot);
END; {else}
END; {Validate}
This structure places the responsibility for handling invalid cases in the class itself, rather than relying on MacApp’s code for mapping error codes to error strings in TDialogView.CantDeselect (never trust a method with a contraction in its name). Given this structure, you can change any step in the validation process without changing the nature of validation itself by overriding IsValid, HandleValidText, or HandleInvalidText. That’s the whole idea behind flow-of-control methods.
HandleValidText simply returns kValidValue (defined in UDialog), after notifying its superview that the text is valid. Two lines of code—no fuss, no muss.
HandleInvalidText has to do a little more, but not much. It calls the method ValidationErrorAlert to notify the user of the problem. Although the default alert has only an OK button, I’ve also added support for a Cancel button. If the user clicks OK, HandleAlertAccepted is called; otherwise—if the user clicks Cancel— HandleAlertCancelled is called.
FUNCTION TValidText.HandleInvalidText(
VAR theText: Str255;
theError: INTEGER)
:LONGINT;
BEGIN
IF ValidationErrorAlert(theText, theError)
THEN
HandleInvalidText :=
HandleAlertAccepted(theText, theError)
ELSE
HandleInvalidText :=
HandleAlertCancelled(theText, theError);
END; {HandleInvalidText}
In either case, a handler routine is called. Again, this kind of flow-of-control method, which calls other methods to do the dirty work, is a very useful addition to the object programmer’s repertoire.
ValidationErrorAlert is equally trivial, consisting of only two lines. The first is a call to PrepareErrorAlert, while the second displays the alert itself, returning TRUE if the user accepts the dialog box and FALSE if the user cancels out of it.
PrepareErrorAlert is also only two lines of code:
PROCEDURE TValidText.PrepareErrorAlert(
VAR theText: Str255;
theError: INTEGER);
{This routine sets up the dialog that is displayed by
ValidationErrorAlert.}
VAR
theString: Str255;
BEGIN
{Get the best string to describe the given error.}
ErrorToString(theError, theString);
ParamText(theString, '', '', '');
END; {PrepareErrorAlert}
PrepareErrorAlert converts the given error code to a string by calling ErrorToString, and then calls ParamText to get the string into the dialog. The error code was generated by IsValid way back in the Validate method.
The essential feature of these routines is that they’re all teeny-tiny pieces of code, each with a single, well-defined goal. Any one of them can be overridden in isolation, to tweak the validation mechanism one way or another. I think you’ll find it to be a big improvement over TEditText’s validation mechanism.
VALIDATING THE DATE
The TDateEditText class allows the user to enter a date string and have the Macintosh Script Manager’s LongDateTime routines figure out what date it is, in a convenient, internationally compatible manner. It can display the resulting date in any of the three formats supported by the Script Manager: short (9-13-91), abbreviated (Fri, Sep 13, 91), or long (Friday, September 13, 1991).
TDateEditText overrides four TValidText methods to implement date validation: IsValid, HandleValidText, ErrorToString, and PrepareErrorAlert.
IsValid looks pretty complicated, and it is—by my standards, anyway. It has to set up not only its Boolean return value, but also an error code if the given text is not valid. This latter chore is complicated by the optional strict checking, embodied in fStrict. The Script Manager provides two different levels of error messages when converting dates (and times) to strings. It will take almost anything you give it and make a date out of it, but it will warn you about leftover characters, nonstandard separators, and the like. Strict checking for dates means that only perfectly formed date strings will be accepted, while nonstrict checking means that so long as a date can be extracted from the string, you don’t want to hear the Script Manager complain about how hard it was to get it.
FUNCTION TDateEditText.IsValid(
VAR theText: Str255;
VAR whyNot: INTEGER)
:BOOLEAN;
OVERRIDE;
VAR
theError: INTEGER;
valid: BOOLEAN;
dateSecs: LongDateTime;
BEGIN
IF (NOT INHERITED IsValid(theText, theError))
THEN
BEGIN
valid := FALSE;
whyNot := theError;
END
ELSE
BEGIN
{Use the Script Manager to convert the date string to a
ELSE {Error codes >= noErr mean a valid date was found.}
valid := (theError >= noErr);
IF (theError = dateTimeNotFound) & {Date isn't found,}
(NOT fRequired) & {empty strings are OK,}
(Length(theText) = 0) {and the string is empty.}
THEN {Empty string is OK if entry isn't required.}
valid := TRUE;
IF valid
THEN
whyNot := noErr
ELSE
whyNot := theError;
END; {else}
IsValid := valid;
END; {IsValid}
HandleValidText just sets the fDateSecs instance variable to reflect the date of the given string, and then calls the inherited version of the HandleValidText routine in TValidText.
Likewise, ErrorToString catches those errors that it knows about and converts them to strings; others, it just passes on to the inherited version of ErrorToString. Don’t you love inheritance?
PROCEDURE TDateEditText.ErrorToString(
theError: INTEGER;
VAR theString: Str255);
OVERRIDE;
{This routine sets theString to the string that best
explains the given error. It's intended to be called
only from PrepareErrorAlert.}
VAR
strIndex: INTEGER;
BEGIN
CASE theError OF
{These are the error codes returned by the Script Manager's
string-to-date routine.}
{strIndex 1 contains the default string, "invalid date".}
leftOverChars: strIndex := 2;
sepNotIntlSep: strIndex := 3;
fieldOrderNotIntl: strIndex := 4;
extraneousStrings: strIndex := 5;
tooManySeps: strIndex := 6;
sepNotConsistent: strIndex := 7;
tokenErr: strIndex := 8;
cantReadUtilities: strIndex := 9;
dateTimeNotFound: strIndex := 10;
dateTimeInvalid: strIndex := 11;
OTHERWISE strIndex := 0; {Not our error.}
END; {case theError}
IF (strIndex > 0)
THEN {It's an error we know how to describe, so handle it.}
ELSE {Never heard of it - ask our superclass to handle it.}
INHERITED ErrorToString(theError, theString);
END; {ErrorToString}
TDateEditText.PrepareErrorAlert (below) calls ErrorToString to convert the given error code to a string. This string will then be displayed in the validation error alert (see Figure 3). It also converts the current system date to a string to be displayed in the alert, where it will serve as an example of the proper date format.
PROCEDURE TDateEditText.PrepareErrorAlert(
VAR theText: Str255;
theError: INTEGER);
OVERRIDE;
VAR
errString: Str255;
dateSecs: LongDateTime;
dateString: Str255;
BEGIN
{Get the current date, as a string.}
GetCurrentDate(dateSecs);
DateToString(dateSecs, shortDate, dateString);
{Get the best string to describe the given error.}
ErrorToString(theError, errString);
ParamText(errString, dateString, '', '');
END; {PrepareErrorAlert}
Figure 3
TDateEditText’s Validation Error Alert
TDateEditText.PrepareErrorAlert can’t call the version of PrepareErrorAlert it inherits from TValidText. The inherited version’s call to ParamText would cloud the effect of the override’s call. I got around this by duplicating the body of TValidText.PrepareErrorAlert in the override, and not calling the inherited version at all. This duplication is a violation of Truth #1 (reusing code is better than writing new code), but I couldn’t figure out how to avoid it—so I just duplicated it, thus adhering to Truth #3 (anything’s better than missing a deadline).
Eventually, if an invalid date like February 31 has been entered by the user, TDateEditText displays an alert similar to that shown in Figure 3.
VALIDATING THE TIME
Given the description and discussion of TDateEditText above, the most striking thing about TTimeEditText is its similarity to TDateEditText. That shouldn’t be
surprising. The validation of dates has been designed to follow a particular series of steps, which can also be applied to time. Validating time therefore involves subtly tailoring the behavior of a few steps rather than writing the validation logic from scratch. You can see this in the code on the Developer CD Series disc, which includes a test application and its source.
WHAT’S DONE IS DONE
If you build the test application yourself and bang on it even a little, you’ll find a bug: if you’ve got invalid text in one editText item, and click on the other, you’ll see the invalid entry alert twice. This is very annoying. Fixing this problem requires a change to MacApp, however, because that’s where the bug lives. Consider MacApp’s TEditText.HandleMouseDown method:
FUNCTION TEditText.HandleMouseDown(
theMouse: VPoint;
VAR info: EventInfo;
VAR hysteresis: Point;
VAR theCommand: TCommand)
: BOOLEAN;
OVERRIDE;
BEGIN
{Get the floating TE installed if necessary.}
IF IsViewEnabled & (gTarget <> fTEView)
THEN
DoChoice(SELF, fDefChoice);
HandleMouseDown := INHERITED HandleMouseDown(
theMouse, info, hysteresis, theCommand);
END; {HandleMouseDown}
The call to DoChoice goes to TDialogView, which attempts to deselect the currently edited item with a call to its Validate method. If validation fails, the validation failure alert is displayed. The subsequent call to INHERITED HandleMouseDown eventually calls DoMouseCommand. This call, in turn, creates and returns a control tracker that eventually calls TDialogView.DoChoice again. TDialogView.DoChoice again attempts to deselect its currently edited item, and the validation again fails (since nothing has changed), displaying the invalid entry alert for the second time.
To fix the problem, we must add an override of DoMouseCommand to TEditText. Just overriding DoMouseCommand in TValidText won’t fix the problem, since the flaw is in TEditText itself.
FUNCTION TEditText.DoMouseCommand(
VAR theMouse: Point;
VAR info: EventInfo;
VAR hysteresis: Point)
: TCommand;
OVERRIDE;
BEGIN
IF (gTarget = fTEView) {Only true when validation succeeds.}
THEN {Validation has succeeded, so Do the Right Thing.}
DoMouseCommand := INHERITED DoMouseCommand(
theMouse, info, hysteresis)
ELSE {Validation failed - stop cold.}
DoMouseCommand := NIL;
END; {DoMouseCommand}
Thus INHERITED DoMouseCommand is called only when all is as it should be.
(I’d like to thank Tom Dinger for suggesting this solution, which is cleaner than my originally proposed change to TEditText.HandleMouseDown.) I added this change to my copy of MacApp, and used it to build the compiled version of the sample application you’ll find on the Developer CD Series disc—so it demonstrates the fix, not the bug.
. . . AND NOW, THE QUIZ
That about wraps up TValidText, TDateEditText, and TTimeEditText. Their use is demonstrated further in the accompanying sample program. You can use the TValidText class as a common basis for the validation of any quantity-related editable text control—such as controls for numbers, currency, and weights and measures—in the same uniform and flexible manner. If you have any questions, I’m sorry, but your time is up: please put down your pencils, and pass your papers forward. Class dismissed!
ACKNOWLEDGMENTS
This article wouldn’t have been possible without the support of Steve Starr, Marian Cauwet, or Ed Lauing, who have made Power Up Software such a great place to work, or my family, who have made my home such a great place to live.
To the former, I give my thanks and respect; to the latter, my love. Many thanks also to my editor, Geta Carlson.
Special thanks to the MacApp engineers, past and present, for writing such a great piece of work. If inflexible string validation is the worst flaw I can find in MacApp, it must be pretty good. And thanks to our technical reviewers: Jesse Feiler of The Philmont Software Mill, author of articles on topics related to this one; Carl Nelson, President of Software Architects and former President of the MacApp Developer’s Association (MADA); Bryan Stearns, Macintosh guru and Tech Note author; and David Taylor of Bear River Associates, author of Calendar Creator 1.0, the first shipping retail application written using MacApp 2.0.
PRINT HINTS FROM LUKE & ZZ
COPYMASK, COPYDEEPMASK, AND LASERWRITER DRIVER 7.0
Luke speaks
With the release of System 7 comes a new release of the LaserWriter driver, version 7.0. Yes, the great implementors (GIs) have once again created another version of this driver. This version supports TrueType fonts, it’s 32-bit clean, it has the new PostScript file-saving capability, and it remembers the last setting of the Black & White and Color/Grayscale print buttons (HOORAY!!).
Along comes our hero, Dudley Developer. He’s been using the new CopyMask and CopyDeepMask calls that are available in QuickDraw in System 7 and he’s very excited about printing his new images with the LaserWriter driver. He assumes that since QuickDraw supports the new CopyMask and CopyDeepMask calls, the LaserWriter driver 7.0 will also support them.
Bad assumption. Our hero has not been keeping up with current events. He has not even read “QuickDraw’s CopyBits Procedure: Better Than Ever in System 7.0” in Issue 6 of develop. If he had, he would know that, like previous versions of the LaserWriter driver, LaserWriter driver 7.0 does not directly support the CopyMask and CopyDeepMask calls.
So, in his ignorance, our hero creates a few pictures with the new QuickDraw calls, and sends them off to the LaserWriter. Time goes by, paper comes out, but the picture doesn’t look the same as it did on his monitor. It has lost some of the cool effects from CopyMask and CopyDeepMask.
Why, he wonders, won’t LaserWriter driver 7.0 print his images with the same effects provided by the CopyMask and CopyDeepMask calls? What was Apple thinking when they created LaserWriter driver 7.0? How could they release a driver that doesn’t support the new 32-bit QuickDraw calls? How do they expect him to print his new cool pictures created in System 7 with these calls?
To attempt to understand the problem, Dudley looks between the covers of the Adobe red book (a.k.a. PostScript Language Reference Manual by Adobe Systems). Even he knows transfer modes would be required to support the new calls—but alas, he doesn’t find any information on them, because PostScript level 1 doesn’t understand transfer modes. Unfortunately, the LaserWriter driver won’t rewrite PostScript for you; it just merrily converts your QuickDraw calls into their equivalent PostScript call. The LaserWriter driver always uses the srcCopy transfer mode when it prints a pixel map, regardless of the mode used when the picture was created. (Why srcCopy? Because of the limitations of the color model and the lack of transfer mode support provided by PostScript
level 1.)
There is a method that will allow Dudley to print the images he created, but as usual with printing, he’ll need to do a little more work: he’ll need to use GWorlds and PrGeneral. Since our hero is not familiar with using GWorlds, he decides to go back through his old issues of develop, hoping for an article. Luckily, he finds just what he’s looking for in Issue 1: “Realistic Color for Real-World Applications” and “Braving Offscreen Worlds.” And the CD contains the sample code that uses GWorlds.
So, after reading the articles and trying the code, Dudley is all set to create an off-screen world to hold his image. He realizes that to get the best print quality, he’ll need to make the GWorld bigger than the picture on the screen. The GWorld should be the size of the
grafPort returned by the application’s call to PrOpenDoc, at the printer’s resolution. Dudley knows he needs a device-independent method to acquire this information, and he knows he can get it by using PrGeneral’s GetRslData opcode. And even better still, he remembers an article about using PrGeneral from Issue 3 of develop. The article was titled “Meet PrGeneral,” and it contained complete sample code. Yippee! After using the GetRslData opcode to determine the resolutions supported by the currently selected printer, he uses the SetRsl opcode to set the printer to the resolution he wants. When his application calls PrOpenDoc, the printer driver will return a grafPort that’s sized correctly for the resolution he chose.
Next, Dudley creates the correctly sized off-screen world and draws his image using CopyMask or CopyDeepMask. He just needs to remember that since the CopyMask and CopyDeepMask calls are not saved in pictures, he needs to make the calls directly into his off-screen world (not relying on DrawPicture). So, when he’s ready to print his image, Dudley uses CopyBits to copy it from his GWorld into the printer’s grafPort with srcCopy. That’s it; his totally cool image has been printed in living color (or anemic gray scales, if he’s printing to the LaserWriter).
This wasn’t so bad, but our hero is wondering—when will the GIs make this easier? When will all of this incompatibility between QuickDraw and the LaserWriter driver improve? That’s a really good question. The GIs tell me things will probably not improve until the new printing architecture is released. In the meantime, you’ve got this way around the problem, and at least it isn’t too ugly!
REFERENCES
• “QuickDraw’s CopyBits Procedure: Better Than Ever
in System 7.0,” develop Issue 6, Spring 1991.
• “Meet PrGeneral, the Trap That Makes the Most of the Printing Manager,” develop Issue 3, July 1990.
• “Realistic Color for Real-World Applications,” develop Issue 1, January 1990.
• “Braving Offscreen Worlds,” develop Issue 1,
January 1990.
• Inside Macintosh, Volume V, Color Manager chapter, Addison-Wesley, 1988.
MACINTOSH DEBUGGING: A WEIRD JOURNEY INTO THE BELLY OF THE BEAST
BO3B JOHNSON
AND FRED HUXHAM
ADAPTED FROM THEIR
TALK AT THE WWDC BY
DAVE JOHNSON
Macintosh debugging is a strange and difficult task. This article provides a collection of tried-and-true debugging techniques Bo3b and Fred discussed at Apple’s Worldwide Developers Conference in May 1991. These techniques can ease your debugging woes and make your life a lot simpler. They’re guaranteed to help you find your bugs earlier on, saving you hours of suffering.
The first thing you should know is that debugging is hard. Drinking gallons of Mountain Dew won’t help much, nor will seeking magic formulas or spreading fresh goat entrails around your keyboard and chanting. The only way to get better at it is to do it a lot, and even then it’s still hard. What we’re going to talk about are a number of techniques that will make debugging a little bit easier.
Notice that the title of this article is “Macintosh Debugging” and not “Macintosh Debuggers.” We’re not going to do a comparative review of debuggers. We’re not going to show you how to use them. In fact, we recommend that you buy and use all the ones described here. Each has useful features that the others don’t have. Which you use most often is up to you—pick one as your main debugger and really get to know it, but keep all of them around.
The main Macintosh debuggers are
• MacsBug from Apple
• TMON (we often refer to version 2.8.4 as Old TMON) and TMON Professional (version 3.0, called TMON Pro for short) from Icom Simulations, Inc.
• The Debugger from Jasik Designs (we’ll call it “Jasik’s debugger” here, because Steve Jasik wrote it, and that’s what everybody calls it in conversation)
We’ll touch on many of the individual features of these debuggers in this article.
THE INSIDE STORY OF THE DEBUGGER
BY STEVE JASIK
WHY WRITE A DEBUGGER
Since I didn’t have the right connections for selling illegal drugs, I had to consider the alternative of selling legal addictive drugs to Macintosh developers.
OK, seriously, I wanted to learn about the 68000 architecture. Given my experience writing compilers and code generators for superscalar RISC mainframes, I decided to write a disassembler for and on the Macintosh. I introduced my first product, MacNosy, in January 1985. It allowed a fair number of developers to discover the innards of the Macintosh ROMs, as well as to curse at me for its original TTY interface.
Unhappy with the state of Macintosh debuggers, I decided to write one of my own, using MacNosy as a foundation. The resulting product, The Debugger, made its international debut in London in November 1986. Since then, it’s been expanded to become a system debugger (it runs at INIT time and is available to debug any process), include an incremental Linker for MPW compiled programs, and more.
THE MACINTOSH INTERFACE
The Debugger uses the Macintosh user interface, or at least my interpretation of it. The windows, menus, dialogs, and text processing are standard for the Macintosh.
The only real problem was the switch in context. I had to swap in all of low memory ($0 to $1E00 on a Macintosh
II-class machine). This may appear to be a bit expensive, but in comparison with the screen swap, which is a minimum of 22K on a small-screened Macintosh, it’s trivial. The biggest problem in this area is that some of the
values have to be “cross-fertilized” between worlds, and many of the low-memory globals are not documented.
Using the Macintosh interface became a royal pain as the System 7 group extended the system in such a way that the basic ROM code assumed the existence of a Layer Manager and MultiFinder functions. In many cases, I had to “unpatch” the standard code and substitute my own in order to keep The Debugger functional.
MMU PROTECTION
MMU protection was initially designed so that The Debugger would try to protect the system from destruction no matter what program was running. As we implemented the design, we found that this goal was impossible because many of the applications (MPW Shell, ResEdit, Finder) diddled with the system heap. I ended up
protecting the rest of the system only when an application that’s being debugged is running.
EASE OF USE
Users have had an influence on the design and feature set
in The Debugger. For example, the initial version of the watchpoint (memory watch) command was very simple.
When a user pointed out the usefulness of an auto reset feature in the command, we added it.
I’ve tried to use simple commands for the most frequently performed operations in The Debugger. The idea has been
to make common things easy to do. Some of the more complicated operations are difficult to keep simple, as the scripting capability is limited. SADE, in contrast, has an extensive scripting capability but is cumbersome to use.
The hardest bugs to find are those that are not reproducible. If you have a crashing bug that can be reproduced 100 percent of the time, you’re well on your way to fixing it. But a bug that crashes your application only once every few hours, at seemingly random times . . . well, that kind can take days or weeks to find. Often the ultimate
failure of a program is caused by code that executed long ago. Tracing back to find the real problem can be difficult and extremely time consuming.
The techniques we show you in this article will help turn most of your random bugs into completely reproducible ones. These techniques are designed to make your software crash or to otherwise alert you as close as possible to where your code is doing something wrong.
We explain what each technique is, why it works, and any gotchas you need to be aware of. Then we tell you how to turn it on or invoke it and list some of the common Macintosh programming errors it will catch. Finally, we show a code sample or two. The code samples were chosen for a number of reasons:
• The errors in many of them are subtle. We couldn’t tell what was wrong with some of them after not looking at them for a couple months, and we wrote them in the first place.
• The mistakes are common. We’ve seen people make these same mistakes time and time again.
• They’re short. They had to fit on one slide at our Worldwide Developers Conference presentation.
So, on to our first technique . . . .
SET $0 TO $50FFC001
The basic idea here is that the number $0 comes up a lot when things go wrong on the Macintosh. When you try to allocate memory or read in a resource, and it fails, what gets returned is $0. Programs should always check to see that when they ask for something from the Toolbox, they actually get it.
Programs that don’t check and use $0 as an address or try to execute from there are asking for trouble. The code will often work without crashing, but presumably it’s not doing what it was meant to do, since there isn’t anything down there that even remotely resembles resources or data in a program.
Why $50FFC001? Old TMON used this number when we turned on Discipline (more on Discipline later). This fine number has the following characteristics:
• Used as a pointer (address), $50FFC001 is in funny space on all Macintosh computers—that is, it’s in I/O space, which is currently just blank. Any relative addresses close by are going to be in I/O space as well, so positive or negative offsets from that as a base will crash, too. These types of offset are common when referencing globals or record fields.
• When used as an address, it will cause a bus error on 68020, ’030, and ’040 machines. Because there’s no RAM there, and no device to respond, the hardware returns a bus error, crashing the program at the exact instruction. Without this handy number, you not only won’t crash, you won’t even know the bug exists (for a while . . . ).
• On 68000 machines, $50FFC001 will cause an address error because it’s an odd number. This also stops the offending code at the exact line that has a bug.
• If the program tries to execute the code at memory location $0, it will crash with an illegal instruction, since the $50FF is not a valid opcode. This is nice when you accidentally JSR to $0 and the program tries to run from there. Those low-memory vectors are certainly not code but don’t usually cause a crash until much later.
• It’s easy to recognize because it doesn’t look like any normal number.
If a program uses memory location $0 as a source for data, this funny number will be copied into data structures. If you see it in a valid data structure someplace else you know there’s a bug lurking in the program that’s getting data from $0 instead of from where it should.
Many different funny bus error numbers can be used. Take your pick.
AVAILABILITY
You can find various programs that set up memory location $0 in this helpful way,
or you can build your own.
• EvenBetterBusError (included on the Developer CD Series disc) is a simple INIT that sets memory location $0 to $50FFC003. It also installs a VBL to make sure no one changes it.
• Under System 7, the thing that used to be MultiFinder (now the Process Manager) takes whatever is in memory location $0 when it starts up and saves it. Periodically it stuffs that saved number back in. If it were a bus error number at system startup (from an INIT, say), that number would be refreshed very nicely. With MacsBug, it would be easy to build a dcmd that stuffs memory location $0 during MacsBug INIT, and MultiFinder would then save and restore that number.
• Jasik’s debugger has a flag that allows you to turn the option on or off.
• Old TMON will set up the bus error number when Discipline is turned on. TMON Pro has a script command, NastyO, that will also do this.
• You can put code in your main event loop that stuffs the bus error number into memory location $0. Be sure to remove it before you ship.
ERRORS CAUGHT
The most obvious catch using this technique is the inadvertent use of NIL handles (or pointers). NIL handles can come back from the Resource Manager and the Memory Manager during failed calls. If a program is being sloppy and not checking errors, it’s easy to fall into using a NIL handle, and this technique will flush it out. A double dereference of a NIL handle will crash the computer. Something like
newArf := aHandle^^.arf;
will crash if aHandle is $0 and we’ve installed this nice bus error number.
This technique will tell when a program inadvertently jumps off to $0 as a place to execute code, which can happen from misaligned stacks or from trying to execute a purged code resource.
By watching for the funny numbers to show up in data structures, you can find out when NIL pointers are being used as the source for data. This is surely not what was meant, and they’re easy to find when a distinctive number points them out. These uses won’t crash the computer, of course.
CODE SAMPLE
theHandle = GetResource('dumb', 1);
aChar = **theHandle;
This is easy: the GetResource call may fail. If the 'dumb' resource isn’t around, theHandle becomes NIL. Dereferencing theHandle when it’s NIL is a bug, since aChar ends up being some wacko number out of ROM in the normal case (ROMBase at $0) and cannot be assumed to be what was desired. This bus error technique will crash the computer right at the **theHandle, pointing out the lack of error checking.
HEAP SCRAMBLE AND PURGE
With this option on, all movable blocks of memory (handles) are moved, and all purgeable blocks are purged, whenever memory can be moved or purged—which is different from moving and purging memory whenever it needs to be moved or purged. This technique is excellent at forcing those once-a-month crashing bugs to crash more often—like all the time. You should run your entire program with this option on, in combination with the bus error technique, using all program features
TMON, THEN AND NOW
BY WALDEMAR HORWAT
The first version of TMON was released in late 1984. TMON was a summer project for me at TMQ Software when I was a junior in high school. I wrote it because I was dreaming about a one-Macintosh debugger (MacsBug required a terminal at the time) that had a direct-manipulation user interface. Direct manipulation meant more than just having windows—it meant you would be able to change memory or registers simply by typing over your values, assemble instructions by typing in a disassembly window, and so on.
the ORIGINAL tmon
Memory constraints of the Macintosh 128K forced me to write TMON entirely in assembly language—the original version used only 16K plus a little additional memory to save the screen. TMON used its own windowing system to avoid reentrancy problems with debugging programs that call the system. TMON also included a “User Area,” a block of code that could extend TMON. The source code was provided for the standard user areas, and Darin Adler took great advantage of this facility to add numerous features to TMON in his Extended User Area.
Writing TMON took a little ingenuity. I didn’t have anything that could debug it, so I wrote the entire program, assembled it, ran it on a Macintosh, and watched it crash. After a couple of dozen builds, I got it to display its menu bar on the screen. By about build 100, I had a usable memory dump window that I could then use to debug the rest of TMON.
TMON PRO
Improving a program written entirely in tight assembly language designed for a Macintosh 128K became intractable, so I switched to MPW C++. Version 3.0 of TMON (TMON Pro) is written half in assembly language and half in C++. Using C++ turned out to be one of the best ways to debug a program: C++ features such as constructors and destructors prevented a lot of pesky programming errors. The downside of using a high-level language is that code size grows explosively—TMON 3.0’s code is about ten times larger than TMON 2.8’s.
When writing TMON 3.0, I reevaluated earlier design decisions. I opted to continue to concentrate on debugging at the assembly language level for two reasons. First, there are many bugs that can arise on a Macintosh that pure source-level debuggers can’t handle. Second, I find that I use TMON at least as much for learning about the Macintosh as I do for debugging.
I sometimes wish I could use the Macintosh windows in TMON. Nevertheless, I decided to remain with TMON’s custom windows for reasons of safety. Until the Macintosh has a real reentrant multitasking system that can switch to another task at any point in the code, writing such a debugger would either make it prone to crashing if it was entered at the wrong time or require the debugger to be more dependent on undocumented operating system internals than I like.
I found that writing TMON 3.0 was much harder and took much longer than writing the original TMON. Part of this was due to the second-system effect—the product just kept on growing over time. Nevertheless, I also found that writing TMON 3.0 was difficult because of the loss of the Macintosh “standard.” There are now over a dozen Macintosh models, using the 68000 through the 68040, some with third-party accelerators, various ROM versions, 24- and 32-bit mode, virtual memory, several versions of the operating system, and numerous INITs, patches, video cards, and other configuration options. These options present unique challenges to a low-level debugger such as TMON, which must include special code for many of them.
Despite the frustration, I think that writing TMON was worth it—it made many developers’ lives easier. I plan to continue to evolve TMON in the future and incorporate suggestions for improvements.
and really putting it through its paces. You’ll be glad you did. Because this debugger option simulates running under low-memory conditions all the time, it stress-tests the program’s memory usage.
AVAILABILITY
All the debuggers have this option, but the one most worth using is in Old TMON and TMON Pro, since it implements both scramble (moving memory) and purge. MacsBug and Jasik’s debugger both have scramble, but they’re too slow, and neither has a purge option.
ERRORS CAUGHT
This technique will catch improper usage of dereferenced or purgeable handles, mistakes that fall into the “easy to make, hard to discover” category. The technique will also catch blocks that are overwritten accidentally, since there’s an implicit heap check each time the heap is scrambled. Warning: The bugs you find may not be yours.
CODE SAMPLE
aPicture = GetPicture(1);
FailNil(aPicture);
aPtr = NewPtr(500000);
FailNil(aPtr);
aRect = (**aPicture).picFrame;
DrawPicture(aPicture, &aRect);
Here, if the picture is purgeable, it might be purged to make room in the heap for the large pointer allocated next. This would make aRect garbage, and DrawPicture wouldn’t work as intended, probably drawing nothing. Here’s a similar example in Pascal:
aPicture := GetPicture(kResNum);
FailNil(aPicture);
WITH aPicture^^ DO
BEGIN
aPtr := NewPtr(500000);
FailNil(aPtr);
aRect := picFrame;
END; {WITH}
Here, even if the picture isn’t purged, the NewPtr call might move it, invalidating the WITH statement and resulting, again, in a bad aRect.
ZAPPING HANDLES
The idea here is to trash disposed memory at the time it’s disposed of in order to catch subsequent use of the free blocks. The technique fills disposed memory with bus error numbers, so that if you attempt to use disposed memory later, the program will crash.
A related option is MPW Pascal’s -u option, which initializes local and global variables to $7267.
AVAILABILITY
This technique is implemented as a part of Jasik’s Discipline option and is also a dcmd, available on the Developer CD Series disc, for TMON Pro or MacsBug. You can also just write it into your program by writing bottleneck routines for disposing of memory (such as MyDisposHandle, MyDisposPtr) that fill blocks with bus error numbers just before freeing them. The problem with this is that memory freed by other calls (ReleaseResource, for instance) isn’t affected. We recommend the dcmd or Jasik’s Discipline.
ERRORS CAUGHT
This technique will catch reusing deallocated memory or disposing of memory in the wrong order. It can also catch uninitialized variables, since after you’ve been running it for a while, much of the free memory in the heap will be filled with bus error numbers.
CODE SAMPLE
SetWRefCon(aWindowPtr, (long)aHandle);
. . .
DisposeWindow(aWindowPtr);
DisposHandle((Handle) GetWRefCon(aWindowPtr));
The GetWRefCon will work on a disposed window, but it’s definitely a bug. Zapping the handles sets the refCon to a bus error number, forcing the DisposHandle call to fail.
CHECKSUM $0
Once again, we’re dealing with the address $0. This technique, however, is sort of the opposite of the first one: it catches writing to $0 rather than reading or executing from
it.
AVAILABILITY
This one is easy: you can set up a checksum so that you’ll drop into the debugger whenever the value at $0 changes. All the debuggers have a way to do this. Also, EvenBetterBusError sets up a VBL to detect if $0 changes, but since VBL tasks don’t run very often (relative to the CPU, anyway), you’ll probably be far away in your
code by the time it notices. It’s still much better than nothing, though, since knowing the bug exists is the first step toward fixing it.
Note that on the IIci the Memory Manager itself changes $0, so you’ll get spurious results. EvenBetterBusError knows about this and ignores it.
ERRORS CAUGHT
The errors caught by this technique are much the same as those caught by the first technique, except that this one catches writes rather than reads. This way, if your code tries to write to address $0 (by dereferencing a NIL handle or pointer), you’ll know.
CODE SAMPLE
aPtr = NewPtr(kBuffSize);
BlockMove(anotherPtr, aPtr, kBuffSize);
This one’s pretty obvious: if the NewPtr call fails, aPtr will be NIL, and the BlockMove will stomp all over low memory. If kBuffSize is big enough, this will take you right out, trashing all your low-memory vectors and your debugger, too.
DISCIPLINE
Discipline is a debugger feature that checks for bogus parameters to Toolbox calls. It would of course be nice if the Toolbox itself did more error checking, but for performance reasons it can’t. (Be forewarned that some versions of the system have errors that Discipline will catch.) Discipline is the perfect development-time test. It catches all those stupid mistakes you make when typing your code that somehow get past the compiler and may persist for some time before you discover them. It can literally save you hours tracking down foolish parameter bugs that should never have happened in the first place.
AVAILABILITY
Old TMON has an early version of Discipline, but there are no checks for Color QuickDraw calls or later system calls, so its usefulness is limited. There is an INIT version of Discipline (on the Developer CD Series disc with MacsBug) that works in conjunction with MacsBug or TMON Pro that’s quite usable, if slow and clunky. Jasik’s version of Discipline is far and away the best; use it if you can.
ERRORS CAUGHT
As you’d expect, Discipline catches Toolbox calls with bad arguments, like bogus handles, and also sometimes catches bad environment states, like trying to draw into a bad grafPort.
CODE SAMPLE
aHandle = GetResource('dumb', 1);
FailNil(aHandle);
. . .
DisposHandle(aHandle);
The problem here is that a resource handle has to be thrown away with ReleaseResource, not DisposHandle. Otherwise, the Resource Manager will get confused since the resource map won’t be properly updated. Sometime later (maybe much later) Very Bad Things will happen.
32-BIT MEMORY MODE
Running in full 32-bit mode in System 7 forces the Memory Manager and the program counter to use full 32-bit addresses: this is something new on the Macintosh. The old-style (24-bit) Memory Manager used the top byte of handles to store the block attributes (whether or not the handle was locked, purgeable, and so forth). By running your program in 32-bit mode, you’ll flush out any code that mucks with the top bits of an address, for any reason, accidentally or on purpose. In the past, many programs examined or modified block attributes directly. This is a bad idea. Use the Toolbox calls HGetState and HSetState to get and set block attributes.
AVAILABILITY
You get 32-bit memory mode with System 7, of course! You use the Memory cdev to turn on 32-bit addressing, available only on machines that have 32-bit-clean ROMs (Macintosh IIfx, IIci, IIsi). You should also install more than 8 MB of RAM and launch your application first, so that it goes into memory that requires 32-bit addressing (within the 8 MB area, addresses use only 24 bits). We also recommend using TMON’s heap scramble in 32-bit mode, since the block headers are different.
ERRORS CAUGHT
You can inadvertently mess up addresses in a bunch of ways. Obviously, any code that makes assumptions about block structures is suspect. Doing signed math on pointers is another one that comes up pretty often. Any messing with the top bytes of addresses can get you into big trouble, jumping off into weird space, where you have no business.
CODE SAMPLE
aHandle = (Handle) ((long) aHandle | 0x80000000);
Naturally, this method of locking a handle is not a good idea, since in 32-bit mode the locked bit isn’t even there. Use HLock or HSetState; they’ll do the right thing.
FULL COMPILER AND LINKER WARNINGS
Always develop your code with full warnings on. When you’re compiling and linking your program, any number of errors or warnings will be emitted. The errors are for things that are just plain wrong, so you’ll have to fix those immediately. Warnings, however, indicate things that aren’t absolutely wrong, but certainly are questionable as far as the compiler or linker is concerned.
We think you should fix every problem as soon as a warning first appears, even if there’s “nothing wrong” with the code. If you leave the warnings in, little by little they’ll pile up, and pretty soon you’ll have pages full of warnings spewing out every time you do a build. You know you won’t read through them every time. You’ll probably just redirect the warnings to a file you never look at so that your worksheet won’t be sullied. Then the one warning that will cause a problem will sneak right by you, and much later you’ll find out that the totally nasty, hard-to-find bug that you finally corrected was one the compiler warned you about a month ago. To avoid this painful experience, deal with the warnings when they appear, even if they’re false alarms.
AVAILABILITY
Use the compiler and linker options that turn on full warnings:
• MPW C++: The “-w2” option turns on the maximum compiler warnings.
• MPW C: Use “-warnings full” (“-w2” does the same thing). In addition, the “-r” option will warn you if you call a function with no definition.
• MPW Linker: The “-msg keyword” option controls the linker warnings. Keyword is one or more of these: dup, which enables warnings about duplicate symbols; multiple, which enables multiple warnings on undefined references to a label (you can thus find all the undefined references in one link); and warn, which enables warnings.
• THINK C: Because the compile is stopped when a warning is encountered, it forces you to fix all warnings. Some people like this; others don’t. We do, but you decide. Be sure that “Check Pointer Types” is turned on in the compiler options.
• Pascal: Most of the things that cause warnings in C are automatically enforced.
If you’re coding in C, it’s also a good idea to prototype all your routines. This avoids silly errors.
ERRORS CAUGHT
The compiler and linker will tell you about lots of things. Some examples are
• the use of uninitialized variables (which is a real bug)
• bad function arguments
• unused variables (these confuse the code and may be real bugs)
• argument mismatches (probably bugs)
• signed math overflow
In C++, overriding operator new without overriding operator delete is probably a bug and unintentional. Even if a warning is caused by something intentional, fix it so that the warning won’t appear.
CODE SAMPLE
#define kMagicNumber 12345
. . .
short result;
result = kMagicNumber*99;
The problem with this code is that the multiplication is overflowing a 16-bit short value. If you have full compiler warnings on, the MPW compiler will let you know this with the following error message:
### Warning 276 This assignment may lose some significant bits
MEMORY PROTECTION
This is something you’ve always wanted: a way to get a protected memory model for the Macintosh. With memory protection on, memory accesses outside the application’s RAM space would be caught as illegal, giving you the chance to find bad program assumptions and wild references. Only Jasik’s debugger has this feature now.
The protected mode is only partly successful, though, since the Macintosh has nothing that resembles a standard operating system. The problems stem from how programs are expected to run, in that references to some low-memory globals are OK, and code and data share the same address space. Given the anarchy in the system, the way Jasik set it up is to allow protection of applications only. The protected mode also protects the CODE resources in the application from being overwritten.
Although this protected mode is not as good as having the OS support protected memory spaces, it’s still a giant leap ahead in terms of finding bugs in your programs. By catching these stray references during development, you can be assured that the
user won’t get random crashes because of your program. This is an ideal development tool for catching latent bugs that don’t often show up. Who knows what a write to a random spot in memory may hit? Sometimes you’re just lucky, and those random “stomper” bugs remain benign, but more often they’re insidiously nasty.
AVAILABILITY
This tool is currently implemented only in Jasik’s debugger. The memory protection is implemented using the MMU, and it slows down the machine by around 20 percent. It’s a mixed blessing, since it will crash on any number of spurious errors— use it anyway.
ERRORS CAUGHT
If the application writes to low memory or to the system heap, it’s probably not what was desired. A few cases could be deemed necessary, but in general, any references outside the application heap space are considered suspect. Certainly, modifying system variables is not a common task that applications need to support. This memory protection will catch those specific references and give you the chance to be sure that they’re valid and necessary.
Writing to I/O space or screen RAM is another problem this technique will catch. Writing directly to the screen is bad form, and only tacky programs (and games, which must do it) stoop this low. Even HyperCard writes directly to the screen; please don’t emulate it. Some specialized programs could make an argument for writing to I/O space, since they may have a device they need to use up there. This protection will catch those references and point out a logically superior approach, which is to build a driver to interface to that space, instead of accessing it directly.
CODE SAMPLE
*((long*) 0x16A) = aLong;
The low-memory global Ticks is being modified. Writing to low-memory globals is a Very Bad Thing to do. This will be caught by memory protection.
LEAKS
A memory leak occurs when a program allocates a block of memory with either NewHandle or NewPtr (or even with Pascal New or C malloc, both of which turn into NewPtr at a lower level), but that block is never disposed of, and the reference to it is lost or written over. If a program does this often enough, it will run out of RAM and probably crash. This leads to the famous statement: “Properly written Macintosh programs will run for hours, even days, without crashing”—a standing joke in Developer Technical Support for so long we’ve forgotten the original source. Naturally, if the program is leaking in the main event loop, it will crash sooner than if
it leaks from some rare operation. If it leaks at all, it will ultimately fail and crash some poor user.
AVAILABILITY
A simple technique that all debuggers support can tell you whether or not the program is leaking. Do a Heap Total and check the amount of free space and purgeable space that’s available. Run the program through its paces and then see if the amount of free space plus purgeable space has dropped. If it has, try again, under the assumption that the program might have loaded some code or other data the first time around. If it’s still smaller, it’s likely to be a leak. This approach, of course, only shows that you have a leak; tracking it down is the hard part. But, hey, you can’t start tracking till you know it’s there.
There’s a dcmd called Leaks (on the Developer CD Series disc) that runs under both TMON Pro and MacsBug. The basic premise is to watch all the memory allocations to see if they get disposed of correctly. Leaks patches the traps NewHandle, DisposHandle, NewPtr, and DisposPtr. When a new handle or pointer is allocated on the heap, Leaks saves the address into an internal buffer. When the corresponding DisposHandle or DisposPtr comes by, Leaks looks it up in the list and, if it finds the same address, dumps that record as having been properly disposed of. Now all those records on the Leaks list that didn’t have the corresponding dispose are candidate memory leaks.
The Macintosh has a lot of fairly dynamic data, so Leaks often ends up getting a number of things on its list that haven’t been disposed of but are not actually leaks. They’re just first-time data, or loaded resources. To avoid false alarms, the Leaks dcmd requires that you perform the operation under question three times, in order to get three or more items in its list that are similar in size and allocated from the same place in the program. An operation can be as simple or complex as desired, since every memory allocation is watched. An example of an operation to watch is to choose New from a menu and then choose Close, under the assumption that those are complementary functions. If you do this three times in a row with Leaks turned on, anything that Leaks coughs out will very likely be a memory leak for that operation.
The dcmd saves a shortened stack crawl of where the memory is being allocated, so that potential leaks can be found back in the source code.
One problem with Leaks as a dcmd is that if it’s installed as part of the TMON Pro startup, it patches the traps using a tail patch. Tail patches are bad, since they disable bug fixes the system may have installed on those traps. This could cause a bug to show up in your program that isn’t there in an unpatched system. It’s still probably worth the risk, given the functionality Leaks can provide. The problem doesn’t exist with MacsBug, since the traps are patched by the dcmd before the system patches them.
A vastly superior way around this problem is to provide the Leaks functionality as debugging code, instead of relying on an external tool. By writing an intermediate routine that acts as a “wrapper” around any memory allocations your program does, you can watch all the handles and pointers go by, do your own list management to know when the list should be empty, and dump out the information when it isn’t. By wrapping those allocations, you avoid patching traps (always a good idea). Be sure to watch for secondary allocations, such as GetResource/DetachResource pairs. You may still want to run Leaks when you notice memory being lost, but your wrappers don’t notice it.
ERRORS CAUGHT
Potential memory leaks, but you knew that already.
CODE SAMPLE
anIcon := GetCIcon(kIconId);
PlotCIcon(aRect, anIcon);
DisposHandle(Handle (anIcon));
This orphans any number of handles, because the GetCIcon call will create several extra handles for pixMaps and color tables. This is an easy error to make, since the GetCIcon returns a CIconHandle, which seems a lot like a PicHandle. A PicHandle is a single handle, though, and a CIconHandle is a number of pieces. Always use the corresponding dispose call for a given data structure. In this case, the appropriate call is DisposCIcon.
STRESS ERROR HANDLING
Here the goal is to see how the program deals with less than perfect situations. Your program won’t always have enough RAM or disk space to run smoothly, and it’s best to plan for it. The first step is to write the code defensively, so that any potential error conditions are caught and handled in the code. If you don’t put in the error-handling code, you’re writing software that never expects to be stressed, which is an unreasonable assumption on the Macintosh.
AVAILABILITY
Try running the program in a memory-critical mode, where it doesn’t have enough RAM even to start up. Users can get into this unfortunate situation by changing the application’s partition size. Rather than crash, put up an alert to tell users what went wrong, and then bail out gracefully. Try running with just enough RAM to start up, but not enough to open documents. Be sure the program doesn’t crash and does give the user some feedback. Try running in situations where there isn’t enough RAM to edit a document, and make sure it handles them. What happens if you get a memory-low message, and you try to save? If you can’t save, the user will be annoyed. What happens when you try to print?
Run your program on a locked disk, and try to save files on the locked disk. The errors you get back should be handled in a nice way, giving the user some feedback. This will often find assumptions in the code, like, “I’m sure it will always be run from a hard disk.”
To see if you handle disk-full errors in a nice way, be sure to try a disk that has varying amounts of free space left. Here again, if you’ve only ever tested on a big, old, empty hard disk, it may shock you to find out that your users are running on a double-floppy-disk Macintosh SE and aren’t too happy that disk-full errors crash the program.
A particularly annoying common error is saving over a file on the disk. Some programs will delete the old file first and then try to save. If a disk-full error occurs, the old copy of the data has been deleted, leaving the user in a precarious state. Don’t force a user to switch disks, but allow the opportunity.
Especially with the advent of System 7, you should see how your program handles the volume permissions of AppleShare. Since any Macintosh can now be an AppleShare server, you can definitely expect to see permission errors added to the list of possible disk errors. Try saving files into folders you don’t have permission to access, and see if the program handles the error properly.
ERRORS CAUGHT
Inappropriate error handling, unnecessary crashes, lack of robustness, and general unfriendliness.
CODE SAMPLE
i := 0;
REPEAT
i := i + 1;
WITH pb DO
BEGIN
ioNamePtr := NIL;
ioVRefnum := 0;
ioDirID := 0;
ioFDirIndex := i;
END;
err := PBGetCatInfo (@pb, False);
UNTIL err <> noErr;
This sample is trying to enumerate all files and directories inside a particular directory by calling PBGetCatInfo until it gets an error. (Note that this sample does one very important thing: initializing the ioNamePtr field to NIL to keep it from returning a string at some random place in memory.) The problem with this loop is that it assumes that any error it finds is the loop termination case. For an AppleShare
volume, you may get something as simple as a permission error for a directory you don’t have access to. This is probably not the end of the entire search, but the code will bail out. This bug would be found by trying the program with an AppleShare volume. The appropriate end case would be to look for the exact error of fnfErr instead or, better, to add the permErr to the conditional.
MULTIPLE CONFIGURATION TESTS
This technique goes beyond merely finding the crash-and-burn bugs to help ensure that the program will run in situations that weren’t originally expected. Just fixing crash-and-burn bugs is for amateurs. Professional software developers want their programs to be as bug-free as possible. As a step toward this higher level of quality, testing in multiple configurations can give you more confidence that you haven’t made faulty assumptions about the system. The idea is to try the program on a number of machines in different configurations, looking for combinations that cause unexpected results.
AVAILABILTY
Multiple configuration tests should use the Macintosh Plus as the low-end machine to be sure that the program runs on 68000-based machines and on ones that have a lot of trap patches. Some of the code the system supports is not available, like Color QuickDraw. If you use anything like that, you will crash with an unimplemented trap number error, ID=12. The Macintosh Plus is a good target for performance testing as well, since it’s the slowest machine you might expect to run on. Its small screen can also point out problems that your users might see in the user interface. For example, some programs use up so much menu bar space that they run off the edge of the screen. That might not be noticed until you run the program on a machine with a small screen. If your program specifically doesn’t support low-end machines, you should still put in a test for them and warn the user. Crashing on a low-end machine is unacceptable, especially when all you needed was a simple check.
Naturally, the multiple configurations include a Macintosh II-class machine to be sure that assumptions about memory are caught. Because most development is done on Macintosh II computers, this case will likely be handled as part of the initial testing. It’s virtually certain that your program will be used on a Macintosh II by some users.
Using multiple monitors on a single system can point out some window- or screen-related assumptions. The current version of the old 512 x 342 fixed-size bug is the assumption that the MainGDevice is the only monitor in the system. Testing with multiple monitors will point out that although sometimes the main device is black and white, there’s a color device in the system. Should your users have to change the main device and reboot just to run your program in color?
By testing the program within a color environment, even if it doesn’t use color, you’ll find any assumptions about how color might be used or the way bitmaps look. It’s a rare (albeit lame) program that gets to choose the exact Macintosh it should run on.
Try the program under Virtual Memory to see if there are built-in assumptions regarding memory.
Use the program under both System 6 and 7. If the program requires System 7, but a user runs it under System 6, it should put up an alert and definitely not crash. For the short term, it’s obvious that you cannot assume all users will have either one system or the other. The number of fundamental differences between the systems is sufficiently large that the only way to gain confidence that the program will behave properly is to run it under both systems. Some bugs that were never caught under System 6 may now show up under System 7. The bugs may even be in your code, with implicit assumptions about how some Toolbox call works.
Doing a set of functionality tests on these various types of systems will ensure that you can handle the most common variations of a Macintosh. Tests of this form will give you a better feeling for the limits of your program and the situations it can handle gracefully. There’s usually no drawback to getting a user’s-eye view of your program.
There is a tool called Virtual User (APDA #M0987LL/B) that can help a lot with these kinds of tests. It allows you to script user interactions so that they can be replayed over and over, and it can execute scripts on other machines remotely, over AppleTalk. So, for instance, you could write a script that puts your program through its paces, and then automatically execute that script simultaneously on lots of differently configured Macintosh systems.
ERRORS CAUGHT
As discussed above, this technique attempts to flush out any assumptions your code makes about the environment it’s running in: color capabilities, screen size, speed, system software version, and so on.
CODE SAMPLE
void Hoohah(void)
{
long localArray[2500];
. . .
}
Naturally, this little array is stack hungry and will consume 10K of stack. On a Macintosh II machine, this is OK, as the default stack is 24K. On the Macintosh Plus,
the stack is only 8K, so when you write into this array you will be writing over the heap, most likely causing a problem. This type of easy-to-code bug may not be caught until testing on a different machine. Merely because the code doesn’t crash on your machine doesn’t mean it’s correct.
ASSERTS
Asserts are added debugging code that you put in to alert you whenever a situation is false or wrong. They’re used to flag unexpected or “can’t happen” situations that your code could run into. Asserts are used only during development and testing; they’ll be compiled out of the final code to avoid a speed hit.
AVAILABILITY
You could write a function called ASSERT that takes a result code and drops into the debugger if the result is false—or, better yet, writes text to a debugging window. In MPW, you can use __FILE__ and __LINE__ directives to keep track of the location in the source code. Another thing to check for is bogus parameters to calls, sort of like Discipline. Basically, you want to check any old thing that will help you ensure consistency and accuracy in your code, the more the merrier, as long as the asserts don’t “fire” all the time. Fix the bugs pointed out by an assert, or toughen up the assert, but don’t turn it off. If you just can’t stand writing code to check every possible error, temporarily put in asserts for the ones that will “never” happen. If an assert goes off, you’d better add some error-handling code.
The following sample code shows one way to implement ASSERT.
#if DEBUG
#define ASSERT(what) do { if(!(what)) dbgAssert(__FILE__,__LINE__); } while(0)
In this example, ASSERT is defined by a C macro. If DEBUG is true, the macro expands to a block of code that checks the argument passed to ASSERT. If the argument is false, the macro calls the function dbgAssert, passing it the filename and line number on which the ASSERT occurs. If DEBUG is false, the macro ASSERT
expands to nothing. Making the definition of ASSERT dependent on a DEBUG flag simplifies the task of compiling ASSERTs out of final code.
ERRORS CAUGHT
This technique catches all sorts of errors, depending, of course, on how you implement it. Logic errors, unanticipated end cases that show up in actual use, and situations that the code is not expecting are some of the possibilities.
CODE SAMPLE
numResources = Count1Resources('PICT');
for(i=1; i<=numResources; i++) {
theResource = Get1IndResource('PICT', i);
ASSERT(theResource != nil);
RmveResource(theResource);
}
The problem here is that the code doesn’t account for the fact that Get1IndResource always starts at the beginning of the available resources. So the first time through, we get the resource with index 1, and we remove it. The next time through, we ask for resource 2, but since we removed the resource at the front of the list, we get what used to be resource 3; we’ve skipped one. The upshot is that only half the resources are removed, and then Get1IndResource fails. This is a great example of a “never fail” situation failing. The ASSERT will catch this one nicely; otherwise, you might not know about it for a long time. The solution is to always ask for the first resource.
TRACE
Trace is a compiler option that causes a subroutine call to be inserted at the beginning and end of each of your functions. You have to implement the two routines (%__BP and %__EP), and then the compiler inserts a JSR %__BP just after the LINK instruction and a JSR %__EP just before UNLK. This gives you a hook into every procedure that’s compiled, which can be extremely useful. Like asserts, trace is debugging code and will be compiled out of the final version.
AVAILABILITY
Trace is available in all the MPW compilers and in THINK Pascal. THINK C’s profiler can be configured and used in the same sort of way.
ERRORS CAUGHT
By being able to watch every call in your program as it’s made, you can more easily spot inefficiencies in your segmentation and your call chain: If two often-called routines live in different segments, under low-memory situations you may be swapping code to disk constantly. If you’re redrawing your window 12 times during
A WORD TO THE WISE FROM FRED
What we’ve described in this article are a number of tools for doing Macintosh software development. Some of you are about to say, “Oh, those sound really great, but I don’t have time to use them—I’m about to ship,” or whatever. I’d like to tell you a story that a man of sound advice, Jim Reekes, told me: A young boy walked into a room and saw a man pushing a nail into the wall with his finger. The boy
asked him, “Hey, mister, why don’t you go next door and get a hammer?” The man replied, “I don’t have time.” So the boy went next door, got a hammer, and came back. The man was still pushing the nail into the wall with his finger. So the boy hit the man in the head with the hammer, killed him, and took the nail.
an update event, you could probably snug things up a little and gain some performance. You can watch the stack depth change, monitor memory usage and free space, and so on. Think up specific flow-of-control questions to ask and then tailor your routines to answer them. Expect to generate far more data than you can look at. Really get to know your program. Go wild.
CODE SAMPLE
PROCEDURE HooHah
VAR
localArray: ARRAY[1..2500] OF LongInt;
BEGIN
. . .
END; {HooHah}
Once again, we’re building a stack that’s too big for a Macintosh Plus. The stack sniffer will catch it eventually, but since VBL tasks don’t run very often, you may be far away by then. Trace could watch for it at each JSR and catch it immediately.
USEFUL COMBINATIONS
All these techniques are powerful by themselves, but they’re even better when used in combination. Use them as early and as often as you can. Some of them are a bit of trouble, but that smidgen of extra work is paid back many times over in the time saved by not having to track down the stupid bugs. Use them throughout development, right up to the end. Many bugs show up through interactions that only begin near the end of the process. Diligent use of these techniques is guaranteed to find many of the easy bugs, so you can spend your time finding the hard ones, which is much more interesting and
worthwhile.
OK, now armed to the teeth with useful techniques, you’re ready to stomp bugs. You know what to look for and how to flush them out. But you know what? Debugging is still hard.
MACINTOSH HYBRID APPLICATIONS FOR A/UX
JOHN MORLEY
Apple’s A/UX operating system is unique among UNIX systems in that it merges the Macintosh user interface and application environment with the multitasking UNIX operating system. Developers can take advantage of this combination by creating a class of applications called hybrids. This article describes the techniques necessary to create Macintosh hybrid applications and demonstrates some of the benefits of these applications.
The UNIX® operating system began some 20 years ago as a personal project undertaken by a couple of engineers at AT&T Bell Laboratories. For a number of technical and business reasons, UNIX emerged as the leading software platform for a phenomenon called Open Systems. Although this buzzword is batted around in many different and confusing contexts, it basically refers to systems that adhere to multivendor industry standards, thus protecting their owner’s investment in software, training, and so on.
At Apple we recognized the growing importance of the UNIX system in many segments of the marketplace, particularly for government, higher education, and large corporate customers. We also understood that the UNIX system’s principal weakness was its lack of ease of use at both the system and application level. By grafting the Macintosh user interface onto a full-featured UNIX operating system, and supporting the bulk of popular Macintosh application software as well, we hoped to meet the requirements of the Open Systems marketplace and retain all the joys of working on a Macintosh.
Release 2.0 of the A/UX operating system was the realization of this effort. When using a Macintosh running A/UX, you can treat it purely as a Macintosh or dive into whatever level of sophistication with the UNIX system your expertise and/or bravado allow.
For the developer, A/UX opens up some new possibilities due to the presence of both the UNIX system and Macintosh programming paradigms. Macintosh developers can use A/UX as a gateway from their Macintosh application into the world of UNIX system services. UNIX system developers can use A/UX to deliver UNIX system applications that incorporate the benefits of the Macintosh user interface.
HYBRID APPLICATIONS
As the name implies, a hybrid application combines two distinct programming models within a single application program. In the case of the A/UX operating system, the two available programming models are the Macintosh Toolbox interface and the UNIX system call interface.
In addition to the two programming models present in A/UX, there are two distinct executable file formats: the UNIX executable file format known as Common Object File Format (COFF) System V.2, and the Macintosh executable file format known as Object Module Format (OMF).
The term Macintosh hybrid application refers to an application that’s represented in Macintosh OMF, primarily uses the Macintosh Toolbox interface, but also accesses the A/UX operating system via the UNIX system call interface.
Alternatively, the term UNIX hybrid application refers to an application that’s represented in COFF, primarily uses the UNIX system call interface, but also accesses the functions provided by the A/UX Macintosh Toolbox.
A/UX MACINTOSH TOOLBOX
The Macintosh Toolbox as it is supported under A/UX is documented in Inside Macintosh Volumes I-V and in A/UX Toolbox: Macintosh ROM Interface. The interface mechanism that’s used to access the Macintosh Toolbox is the set of A-line trap instructions reserved for this purpose in the Motorola 680x0 architecture. The high-level languages supporting Macintosh programming contain features that allow the programmer to use traditional procedure call notation to access the Macintosh Toolbox. The compiler then translates those procedure calls into the actual A-line trap instructions to access the Toolbox.
A/UX SYSTEM CALLS
The UNIX system call interface is documented in the A/UX Programmer’s Reference, Section 2. The interface mechanism that’s used to access the UNIX system calls is a CPU trap instruction that causes a context switch between the application program, which runs in user mode, and the UNIX system kernel, which runs in supervisor mode. The A/UX C runtime library contains procedures to access each of the UNIX system calls supported by A/UX.
Macintosh applications running on A/UX may also access the UNIX system calls. An MPW library (libaux_sys.o) that contains procedures for each UNIX system call, analogous to the ones in the A/UX C runtime library, is included on the Developer CD Series disc for this issue. By calling routines from this library a Macintosh application becomes a Macintosh hybrid application with access to the capabilities provided by the UNIX system.
WHY CREATE MACINTOSH HYBRID APPLICATIONS?
There are several reasons why you might want to create a Macintosh hybrid application. Here are some examples:
• to create a Macintosh style front-end interface for an existing character-based UNIX system application
• to access UNIX system networking from a Macintosh application
• to execute UNIX system applications and utilities from a Macintosh application
The class of applications that act as front ends to existing UNIX system programs is of particular interest. The UNIX operating system has been around for two decades and a large body of software exists that can be ported easily from one UNIX system to another. The problem with these applications is that they were designed to work with character-oriented display devices.
Most people who are familiar with the Macintosh user interface are reluctant to sacrifice the ease of use that applications designed for the Macintosh provide. One way to “dress up” these older UNIX system applications is to provide a Macintosh- style user interface via an application that acts as a front end to the existing character-based application. While not as elegant a solution as redesigning the application with the new user interface in mind, the front-end approach can usually be implemented in less time and at less expense.
MULTITASKING AND THE MACINTOSH
A developer creating a Macintosh hybrid application needs some understanding of Macintosh multitasking and how it’s implemented by A/UX. If not properly designed, a Macintosh hybrid application can easily cause the Macintosh Toolbox environment within A/UX to become deadlocked. Following the guidelines given here can keep the number of catastrophic failures during development to a minimum.
The Macintosh was designed to be a personal computer. This resulted in emphasis on the interaction between a single user and the computer while performing a single task. With the advent of MultiFinder the Macintosh became capable of switching between two or more active applications as well as performing some limited processing in the background while the user interacts with any application.
To avoid major incompatibilities with the existing base of application software, MultiFinder was cleverly designed to implement multitasking on top of the existing Macintosh programming model. This style of multitasking is called cooperative multitasking. The name conveys the requirement that applications must provide the system with a cue indicating when it’s reasonable to interrupt them.
The UNIX operating system, on the other hand, was designed to control minicomputers that normally support many users at once. These computers require the operating system to preemptively schedule tasks for execution using a well-defined scheduling algorithm. A/UX fully implements this style of preemptive multitasking for all UNIX processes.
To implement the MultiFinder method of cooperative multitasking within the preemptive multitasking model of the UNIX system, a special thread of control is defined for all processes that access the A/UX Macintosh Toolbox. The A/UX kernel associates one and only one process at a time with the token of control for the Macintosh Toolbox. The token of control is passed in the same way that applications are activated under MultiFinder.
THE PERILS OF MULTITASKING
An unsuspecting programmer creating a Macintosh hybrid application can easily be tripped up by lack of knowledge about the multitasking environment. Consider the following program:
#include <StdIO.h>
main()
{
char buf[100];
int len;
write(1,"Type Something\n",15);
len = read(0,buf,100);
write(1,"You Typed: ",11);
write(1,buf,len);
write(1,"\n",1);
}
This rather primitive piece of code can be compiled with MPW C and linked to produce an MPW tool. When run, it writes a prompt to the active MPW window and waits for keyboard input terminated by the Enter key. The program then echoes the input to the window and terminates. During the time that the program is waiting for keyboard input, you can switch MultiFinder layers by clicking in a different application window or choosing from the Apple menu or MultiFinder application icon in the menu bar.
This same program can be compiled and linked with the A/UX C compiler (cc or c89) to produce a native COFF application. When run within a CommandShell window it exhibits the same behavior as when compiled with MPW C, including the ability to switch MultiFinder layers while waiting for input from the keyboard.
The program can be modified so that when compiled with MPW it becomes a Macintosh hybrid application. (See “Compiling and Linking Macintosh Hybrid Applications” for some useful tips.) This is done by substituting calls to the A/UX system call routines in place of the standard MPW C runtime routines, as follows:
#include <StdIO.h>
#include <LibAUX.h>
#include </:usr:include:fcntl.h>
main()
{
char buf[100];
int len, fd;
fd = auxopen("/dev/ttyC1",O_RDWR);
(void) auxwrite(fd,"Type Something\r",15);
len = auxread(fd,buf,100);
(void) auxwrite(fd,"You Typed: ",11);
(void) auxwrite(fd,buf,len);
(void) auxwrite(fd,"\r",1);
(void) auxclose(fd);
}
The program now opens the device associated with the window CommandShell 1 and performs the I/O to that window. However, this program contains a serious flaw—the call to auxread will result in a deadlock situation, because as yet there is no data available to be read from the file descriptor associated with the CommandShell window, and the A/UX read system call blocks when data is not available. As a result, the entire MultiFinder environment running on A/UX is suspended. This makes it impossible to switch to CommandShell 1 and enter data via the keyboard.
In this example it’s not too difficult to solve the problem of blocking. The A/UX system call interface allows you to perform I/O that’s nonblocking, otherwise referred to as asynchronous I/O. You can use the A/UX system call fcntl to change the blocking status of a UNIX system file descriptor. Here’s how to modify the previous example so that the deadlock situation is avoided:
#include <StdIO.h>
#include <CursorCtl.h>
#include <LibAUX.h>
#include </:usr:include:fcntl.h>
COMPILING AND LINKING MACINTOSH HYBRID APPLICATIONS
There are a few things you should know in order to compile and link a Macintosh hybrid application:
• Use the include file LibAUX.h to define the system calls and their prototypes (especially if you’re using C++). For example:
#include <LibAUX.h>
• You may need to include A/UX system header files for some of the system calls. These must be specified using the complete pathname in the Macintosh file system format. You must include LibAUX.h before including any A/UX system header files. For example:
#include <LibAUX.h>
#include </:usr:include:fcntl.h>
For information on when to include header files refer to A/UX Programmer’s Reference, Section 2, and A/UX Development Tools, Chapter 2.
• The meanings of the special characters \n and \r are reversed between MPW C and A/UX C. In general,
use \r within strings that are passed to A/UX system calls.
• It’s a good idea to have the application test to see that A/UX—not the Macintosh operating system—is running. To do this, call function AUXisRunning, which returns a nonzero value if A/UX is running or a zero value if it’s not.
• You must link with the library libaux_sys.o to access the system call routines. The default filename for this library is
{MPW}Libraries:AUX System Calls: libaux_sys.o
This library name should be included in addition to any other library names and options you usually include with your Link command.
main()
{
char buf[100];
int len, fd, flags;
/* Open the device associated with CommandShell 1's window.*/
fd = auxopen("/dev/ttyC1",O_RDWR);
/* Get the current flags for this file descriptor.*/
flags = auxfcntl(fd,F_GETFL,0);
/* Add the O_NDELAY flag to the flags that are already set.*/
(void) auxfcntl(fd,F_SETFL,flags | O_NDELAY);
(void)auxwrite(fd,"Type Something\r",15);
while ( (len = auxread(fd,buf,100)) < 1)
SpinCursor(1);
(void)auxwrite(fd,"You Typed: ",11);
(void)auxwrite(fd,buf,len);
(void)auxwrite(fd,"\r",1);
/* Reset the flags to their original state.*/
(void)auxfcntl(fd,F_SETFL,flags);
(void)auxclose(fd);
}
The A/UX system call fcntl is used first to get the file descriptor flags associated with the CommandShell window and then to set the O_NDELAY bit in the flags word. The O_NDELAY bit determines whether reads from the file descriptor will block if data is not available. With this bit set, when data is not available the value returned by the read system call is 0. The call to the MPW library routine SpinCursor creates idle time for the layer switch to occur. The last call to auxfcntl resets the flags to their original state.
If you want to try this example hybrid application, open a CommandShell window under A/UX, type “sleep 1000” in the window, and then run the example from the MPW shell.
HELPFUL UTILITY FUNCTIONS
For many types of potential Macintosh hybrid applications, particularly the front-end variety, the only UNIX system functionality necessary is the ability to execute a UNIX process and communicate with it. Toward this end I’ve included in the system call library several utility routines that are at a higher level than the basic system calls. A description of these utility routines follows.
AUXFORK_PIPE
The auxfork_pipe function executes several system calls to create a new UNIX process. In UNIX system parlance, the new process is the child and the process that created it is the parent. The definition for this function is
Handle auxfork_pipe(int toparent, int tochild, void (*childtask)(),
void *childarg);
The parameters toparent and tochild are flags that indicate whether or not to establish a communication pipe in either direction between the parent and child processes. A zero value signifies that no pipe should be created and a nonzero value signifies that a pipe should be created.
The parameter childtask is a function pointer used to identify a function to be called by the child process when the child process is first created. The parameter childarg is a generic pointer passed to the function pointed to by childtask so that you can vary the behavior of that function. Typically, the function pointed to by childtask executes one of the variants of the exec system call and uses the childarg pointer to identify the filename of the program to be executed.
The value returned by this function is either a handle to a structure that holds some global information about the child process or a null pointer if the call was unsuccessful. The definition for this structure is as follows:
struct childinfo {
/* file descriptor for parent->child communication pipe */
int tochild;
/* file descriptor for child->parent communication pipe */
int toparent;
/* process ID of the child process */
int pid;
};
The file descriptor for the toparent communication pipe has the O_NDELAY bit set in its flags word so that reading from this file descriptor won’t cause a block when data is not available.
AUXCLEANUP_FORK_PIPE
An additional utility function is used to clean up after the child process terminates—the auxcleanup_fork_pipe function. Its definition is
int auxcleanup_fork_pipe(Handle globals);
It takes one parameter, which is the handle returned previously by the auxfork_pipe function. You must be sure that the child process has terminated or is about to terminate before calling auxcleanup_fork_pipe. If you’re not sure that the child process will terminate, you can call auxkill to send the child process a termination signal.
AUXFGETS
The auxfgets function uses the read system call to read a string of characters from an open UNIX system file descriptor. The definition for this function is
char *auxfgets(char *buf, int count, int file, int timeout);
The buf parameter is a pointer to space in which to store the characters read.
The count parameter specifies the maximum number of characters to read. The file parameter is the UNIX system file descriptor from which to read. (The auxfgets function described here differs from the standard fgets function in that it uses a file descriptor rather than a stream pointer.) The timeout parameter indicates the maximum number of times to retry the read system call when data is not available.
This function reads characters until one of the following conditions occurs:
• A newline character (0x10) is read.
• The number of characters specified in the count is reached (reserving room for a null character to mark the end of the
string).
• The retry count specified in the timeout parameter is reached without any new data being available to read. If the value of timeout is 0, auxfgets retries indefinitely.
The newline character, if any, is stored at the end of the character string. In any case, a null character is appended after the last character stored to mark the end of the string.
AUXSYSTEM
The auxsystem function works much like the UNIX library routine named system. To use this function in a Macintosh hybrid application, the application must either be linked as an MPW tool or linked with the Simple Input/Output Window (SIOW) package, which implements standard I/O streams for Macintosh applications. The definition for this function is
int auxsystem(char *command);
The parameter is a pointer to a character string that contains a valid UNIX system shell command (Bourne shell syntax). This function executes the given command and redirects any output that the command produces on the standard output or standard error streams to the SIOW standard output and standard error streams.
The MPW tool Unixcmd included on the Developer CD Series disc is an example of a tool that uses the auxsystem function. This tool executes the UNIX command given on the command line for Unixcmd. The standard output and standard error streams produced by the UNIX command are sent to the MPW window from which Unixcmd was executed, or they can be individually redirected using the MPW shell’s redirection syntax. The Unixcmd tool also sets the MPW variable {Status} to the exit status of the UNIX command, so that MPW scripts can test the exit status.
THE UNIX MAIL READER
To demonstrate some of the techniques used to create Macintosh hybrid applications, we’ll look at an example front-end application for the Berkeley UNIX system mail reading program, mailx. The application is implemented using a HyperCard stack with HyperTalk® scripts that access HyperCard XFCNs.
The interface for the mail reader consists of two cards in a HyperCard stack.
The first card is called headers and is used to display a list of header lines identifying the available mail messages. The second card is called message and is used to display the content of a selected message.
The UNIX Mail Reader example is provided solely to illustrate the technical issues involved in creating an A/UX Macintosh hybrid application. It is not an example of good user interface design, since it was written by a UNIX hacker (yours truly) with
little knowledge of Macintosh user interface guidelines (a little knowledge is a dangerous thing).
HYPERCARD XFCNS
A HyperCard XFCN is a code segment that the HyperCard application calls to perform a function that can’t be accomplished with the standard HyperCard commands. By providing HyperCard with XFCNs to access UNIX system calls,
you can create Macintosh hybrid applications that are implemented by HyperTalk scripts. Five different XFCNs are used by the UNIX Mail Reader to create a HyperCard front end to the UNIX mail reading program. The XFCNs used are as follows:
• forkpipexfcn, which calls the auxfork_pipe utility function
• fgetsxfcn, which calls the auxfgets utility function
• fgetfxfcn, which makes multiple calls to the auxfgets utility function
• writexfcn, which calls the auxwrite utility function
• cleanupxfcn, which calls the auxcleanup_fork_pipe utility function
The source code for these XFCNs is included on the Developer CD Series disc to serve as a model for other XFCNs you may create.
THE ENTRY SCRIPT
When the UNIX Mail Reader stack is opened, the HyperTalk script associated with the headers card is executed.
on openStack
global global_handle, linecount
put empty into cd field one
put empty into global_handle
put forkpipexfcn("/usr/bin/mailx") into global_handle
- - A real application would give an error message here.
if global_handle is empty then go to home
- - Call fgetsxfcn to read first line of mailx output.
put fgetsxfcn(global_handle,2500) into buf
- - Check if any mail is available.
if word 1 of buf is "No" then
- - Inform user there’s no mail.
put cleanupxfcn(global_handle) into status
put empty into global_handle
Beep 1
answer "Sorry, no mail"
go to home
else
- - Inform user there’s mail.
play "mail.sound"
- - Discard 2nd line of mailx output.
put fgetsxfcn(global_handle,2500) into buf
- - Read available mail headers.
repeat with linecount = 1 to 9999
put fgetsxfcn(global_handle,250) into buf
- - Check if done.
if length(buf) = 0 then exit repeat
put buf into line linecount of cd field one
end repeat
- - Calculate number of messages.
subtract 1 from linecount
end if
end openStack
After some initialization, the XFCN forkpipexfcn is called to start execution of the Berkeley UNIX system mail reader located in the file /usr/ucb/mailx. Then, the XFCN fgetsxfcn is called to read the first line of output from the mailx program into the HyperTalk variable buf.
Notice that the second parameter to fgetsxfcn is the value 2500. This parameter is the timeout count described in the definition of auxfgets. The value 2500 was derived by observing the longest time it normally takes for the mail program to begin execution and produce the first line of output.
The script tests the string that was just read to see if it’s the special message that indicates no mail messages. If it is, the script notifies the user and exits.
If the first message is other than the no-mail message, the script reads the header for each message and places it sequentially in the message headers field on the headers card. The message headers begin with the third line of output from the mailx program, so the script reads and discards the second line of output from the mailx program. After the final message is read, the global HyperTalk variable linecount is set to the total number of messages. The final message header is identified by checking to see if the last fgetsxfcn call returned no data, indicating a timeout.
Figure 1 shows the headers card of the UNIX Mail Reader example.
THE EXIT SCRIPT
When the user clicks the Home button, the UNIX Mail Reader stack exits and the following script associated with the headers card executes:
Figure 1
Headers Card With Sample Mail Headers
on closeStack
global global_handle
if global_handle is not empty then
answer "Update Message Queue?" with "Yes" or "No"
if It is "No" then
put writexfcn(global_handle,("x" & lineFeed)) into writecount
else
play "empty trash (flush)"
put writexfcn(global_handle,("q" & lineFeed)) into writecount
end if
put cleanupxfcn(global_handle) into status
put empty into global_handle
end if
put empty into cd field one
play "bye.sound"
end closeStack
This script asks if the user wants to update the message queue, which permanently deletes any messages marked for deletion. Depending on the user’s response, the script sends either the exit command (indicated by the letter x) or the quit command (indicated by the letter q) to the mailx program to terminate the session. The commands are sent to the mailx program by writing to the communication pipe with the XFCN writexfcn. The special character lineFeed is appended to the command to simulate the user pressing the Return key.
The script then calls cleanupxfcn to perform the termination processing. This is safe now, since the mailx program will be terminating as a result of the exit or quit command just sent.
THE SELECTION SCRIPT
When the user clicks one of the message headers displayed in the first card of the stack, the following script is executed to display the selected message in the second card of the stack. Figure 2 shows a message card with a sample message.
on mouseUp
global global_handle, linecount, vline
put (item 2 of the clickLoc) + (the scroll of cd field one) into vline
divide vline by the textHeight of cd field one
put trunc(vline+.6) into vline
if vline <= linecount then
select line vline of cd field one
if the textStyle of the selectedLine is italic then
beep 1
else
put writexfcn(global_handle,(vline & lineFeed)) into writecount
play "ZoomUp"
go to card 2
put fgetfxfcn(global_handle,250) into cd field msgx
end if
else
beep 1
end if
select empty
end mouseUp
This script computes the line number of the selected message, checks to see that it’s a valid message number, and then sends this value to the mailx program, causing that message to be displayed. The call to fgetfxfcn reads multiple lines of output into a field with one XFCN call. This is much faster than calling fgetsxfcn several times and inserting each line into the field.
Figure 2
Message Card With a Sample Message
THE DELETE BUTTON SCRIPT
Users viewing the content of a message in the second card of the stack have the option of marking the message for deletion by clicking the Delete button. That causes the following script to be executed:
on mouseUp
global global_handle, vline
play "Cash Register"
put writexfcn(global_handle,("d" & lineFeed)) into writecount
put empty into cd field msgx
go to card 1
select line vline of cd field one
set textStyle of the selectedLine to italic
end mouseUp
This script sends the delete command (the letter d) to the mailx program, clears the message field on the second card, and then changes the text style of the header for
that message to italic. This is an indication to the user that the message has been marked for deletion. The text style is checked in the selection script to prevent access to a deleted message.
PARTING THOUGHTS
I hope this article has given you some insight into the possible uses of programming Macintosh hybrid applications for A/UX, as well as some helpful techniques for doing this on your own. Although HyperCard was used to quickly implement the UNIX Mail Reader, the same techniques apply to using UNIX system calls from a Macintosh application written without HyperCard.
The A/UX Developer’s Tools set of CD-ROM discs (APDA #B0596LL/A) contains more tools for dealing with both UNIX and Macintosh hybrid applications on A/UX. Developers interested in exploring this programming technique in depth may want to acquire that product to supplement the library and examples from this article.
REFERENCES
• A/UX Programmer’s Reference, Section 2, Apple Computer, 1990.
• A/UX Development Tools, Chapter 2, Apple Computer, 1991.
• A/UX Toolbox: Macintosh ROM Interface, Apple Computer, 1990.
• Apple HyperCard Script Language Guide: The HyperTalk Language, Addison-
So here I am in Tucson, Arizona, standing in a dry streambed reeking of sunscreen with a notebook computer contraption in my hands and a walkie-talkie hooked on my pants and a squawking headset barely staying on my head, watching people tying white cotton string from one tree to another. Every time I move my head the headset slips forward a little more, but my hands are completely filled with this device, a fairly delicate thing due to the wire and duct tape and Velcro attachments, and I can’t find any place safe to put it down. So I’m trying not to move my head, and I’m trying to look like an intelligent and purposeful person at the same time. It’s hard.
I had written a little piece of the software that’s running on the notebook computer, which is a GRiDPAD (pen-based, small, DOS). There are three others like it scattered around the canyon I’m in. Each has a tiny wireless modem and a battery stuck to the back, and each is running a sort of collaborative spreadsheet: data entered in one is quickly picked up by all the others. I’ll call this contraption The Device from now on, to avoid funny capitalizations.
This event is an experiment in wireless communication and in collaboration at a distance. The main participants are a bunch of elementary school kids and their science teachers. They’re here to study the canyon, and are split into four groups, each of which is being deployed to a different spot to take environmental measurements (pH,
temperature, and so on) and to count species. Each group has one of The Devices, so once we’re set up everybody will be able to see everybody else’s data all the time. Each group also has a walkie-talkie, so they’ll be able to talk to one another. We’ve just arrived for the very first field trials.
The string people have finished, neatly delineating the area that is our group’s responsibility. The kids energetically begin fooling with thermometers and vials and yardsticks and—everyone’s favorite—sling psychrometers. I finally find a rock flat enough to put The Device on, just as the headset lets go and slips over my eyes, pulling the earplug out of my ear. Gathering together the shredded remains of my dignity, I disentangle the headset from my ears and sunglasses, put it back on my head, and reinsert the little earplug in my ear. Who designed this thing? It just won’t stay put. Maybe my head is a weird shape, or maybe this headset isn’t meant to be used with sunglasses on. I take off the headset, take off my sunglasses, put the headset back on, and it’s just as bad. Must be my head.
There are some very large issues that are touched on by this experiment, directly or indirectly: the implications of wireless communication, the nature of collaboration, and the nature of communication itself. I’ll take a closer look at these issues, with the assumption up front that the goal is to provide technology that can enable—and hopefully enhance—collaboration at a distance.
First of all, what does wirelessness mean exactly? At face value, not much: it means that the wires are gone. The information flow hasn’t changed; it’s just using a different medium to flow in (or on, or around, or whatever). One person involved in this project compared the advent of wireless communication to taking down the fence around a herd of captive buffalo. Will they burst from their former confinement, joyously kicking their heels (I’m not sure if buffalo have heels, but you get the idea) and searching out new limits to conquer? Or will they not even notice, so used to the way things were that they can’t conceive of anything else? That would be like some large, unimaginative corporation’s vision of wirelessness: the
wires vanish, which saves a little money and hassle setting up the office, but nothing else changes. Clearly an approach like this is doesn’t take advantage of the situation.
Wireless communication adds a whole new degree of freedom to human communication, that of space. It makes communication position-independent, it unsticks people geographically. This is potentially a far-reaching freedom if high-bandwidth wireless communication becomes pervasive. Many existing institutions—schools, businesses, and so on—that largely evolved from the need to have a central physical place are now freed up, just like the buffalo, and have lots of new territory to explore. Maybe there are other ways of doing things without people’s bodies in attendance that we haven’t thought of yet, since we haven’t had the opportunity. But will people take advantage of this new freedom? Or are we too cozy, too entrenched in our old familiar ways to transcend them?
Periodically pushing my headset back onto my head, I look around: chaos reigns, but it’s a good, busy, productive sort of chaos. The kids are measuring things, counting plants and birds and spiders, clambering around in the brush, chattering incessantly on their walkie-talkies, and entering data into The Device; the video crew—ostensibly documenting the event but mostly invoking Heisenberg’s Uncertainty Principle—are running around poking their cameras and microphones at people; the adults are watching carefully, coordinating when necessary, commenting on the action over their own walkie-talkie channel.
One thing that surprises me about how the kids are relating to The Device is that they pretty much take it for granted. I guess I expected them either to ignore it or to be amazed by it, but they seem to just take it in stride, and use it when it’s appropriate.
It occurs to me that that’s probably the best reaction we could hope for, to see it for what it is—a tool—and use it accordingly. And yes, by golly, the kids are collaborating a little. It’s hard to tell, though, whether they’d collaborate on their own. They know that’s what the adults are looking for, and
every school kid learns early on to do what they think their teachers want.
What The Device provides very nicely is a kind of shared data space. It’s as if each group has a magic looking glass that lets them all see the same thing, despite being physically separated. What The Device doesn’t provide is a communication channel that lets them discuss the data with each other. The walkie-talkies provide that channel, although in a stilted manner. To collaborate effectively, you really need both kinds of communication: the communication of data (the shared thing you’re collaborating on) and the communication of instructions (the conversation about the thing you’re collaborating on).
One really interesting point (hotly debated in the post-study debriefing) is the importance of including voice capabilities in new communication/collaboration hardware. There is no question that voice, or more generally language, is the primary medium we use to communicate. The debate pivots on whether voice should be provided de facto in the technology or whether there is some new, as-yet-undiscovered mode of communication that technology can provide us that would render voice communication unnecessary, or at least optional. Pretty heady stuff, no? We’re talking about a quantum leap here, a revolutionary change away from the familiar. Using voice only because it’s the way we do it now might hinder or prevent our moving forward into the grand and glorious communication revolution.
On the other hand, why should we not provide voice? Voice compression technology is advancing quickly because of cellular demand. Good-quality voice can be transmitted at 4800 bits per second now, and soon it will be 2400. Those bandwidths are easy and getting easier and cheaper all the time. Full-duplex real-time voice transmission (in other words, a conversation) also provides a huge degree of familiarity to people, and it really adds to the feeling of being connected. Isn’t that the goal? To be apart but not to feel apart? Voice alone provides lots of that “in the same space” kind of feeling.
My thoughts seem to keep circling back to one central question: should we use this radical new wireless technology to adopt (and then attempt to improve upon) the way people communicate and collaborate now, or should we throw out all the rules and go for something really new? If you’re interested in selling products today, probably you want something like the former. If you’re a wild-eyed visionary intent on changing the world, you’ll tend toward the latter. And in reality, let’s face it, you always end up with something in between.
In my humble and inexpert opinion, we ought to build from familiarity. I don’t really have any facts or studies to back me up, just personal observations and a strong feeling that building from existing modes of communication is the most effective way to get what we want. And I don’t think that this method necessarily precludes radical advances. Look at the Macintosh. Few people would argue against the fact that it was a radical leap from any other machine. But the very thing that made it radical was its familiarity, its humanness. Humanness in a machine is extremely powerful, and extremely attractive to people.
Maybe I just have a soft spot for humans, being one myself, but I tend to give them a lot of credit. The advent of wireless communication does remove a fence, but it is a fence around people, not buffalo. People explore, it’s one of the things they’re best at. They won’t stay huddled in the center of the corral for long. And I also believe that people already know how to collaborate. If you and I are standing next to each other looking at a piece of paper that we’re working on together, we won’t have trouble proceeding. So if we can provide communication tools that are truly transparent, I think that collaboration will fall out automatically. Now don’t get me wrong. I know that there’s plenty of room for improvement in the way people work together, but I think the communication tools need to be available before we can make much progress in collaboration. And yeah, I really think we should provide voice, if we can. If there are better ways to communicate, I suspect it will be quite a while until we find them, and in the meantime voice is the best we’ve got and really does make people feel connected.
It will of course take a while for all these things to come to fruition, but we are tantalizingly close.
I think the best way to proceed is to build what we can right now, and get it out into the world as quickly as possible. Then, to learn how to make it better, we should watch very closely what people do with it. This way the tools will evolve as natural extensions of the people who use them, which seems like a good goal to me. Maybe if the headset makers had followed this approach . . .
MACINTOSH Q & A
Q When my application is running, it relies on the MultiFinder’s “puppet strings” (which choose Open from the application’s File menu and suppress the SFGetFile dialog) to open a document that was double-clicked in the Finder. Why doesn’t this work under System 7? The high-level event-aware bit in my 'SIZE' resource is clear.
A System 7 will not pull puppet strings for an application that makes use of the System 7 Standard File routines, such as StandardGetFile and CustomGetFile, nor will it pull them if the application’s high-level event-aware bit is set.
If you update an older application to take advantage of any System 7 features, be sure to also add support for the 'odoc' and other required Apple events. Sample code showing how to support the required Apple events is available on the System 7 Golden Master CD.
Q Why does Gestalt tell me I have Color QuickDraw features on a non-Color QuickDraw machine?.
A The gestaltQuickdrawFeatures ('qdrw') selector, used for determining your system’s Color QuickDraw features, has a bug that causes it to tell you incorrectly that noncolor machines have color. The fix is quite simple: Gestalt has another selector, gestaltQuickdrawVersion ('qd '), which simply returns the QuickDraw version number. This version number is < gestalt8BitQD for classic QuickDraw and >= gestalt8BitQD for Color QuickDraw (see Inside Macintosh Volume VI, page 3-39, for more information). The trick is to ask Gestalt for the QuickDraw version first; once you’ve determined that you have Color QuickDraw, the 'qdrw' selector is OK to use to find out specifics.
Q What do we return to the Apple event handler if we get an application error while processing a standard event, Edition Manager event, or custom Apple event for commands and queries? Probably not errAENotHandled, since that means we didn’t handle the event, which is different from trying to handle it and failing. Would it be errAEFail? What if we want to return more specific error information? Do we define our own errors, or try to use Apple’s errors such as memFullErr or parmErr?
A You pass back errAENotHandled, because it’s true, and because some simple applications will not be able to handle anything more than that. What you can also do, and what most commercial applications will do (particularly applications that want to be scripting savvy), is add errn and errs parameters to the reply record for that event (as shown on page 6-49 of Inside Macintosh Volume VI). You can be as descriptive as you like in the text—the more the better, in fact, since this text will be seen at the user level usually. The errn value you pass back can be the system error number; then the sending program may be able to recover and try again.
Q According to the QuickTime Movie Toolbox documentation, “The Movie Toolbox maintains a set of global variables for every application using it.” How much global memory is required? Our application is shy on global data space.
A The information maintained is not kept with the application’s global variables. The handle created by the EnterMovies call is stored in the system heap, not in the application heap. You don’t have to worry about how much space to allocate in your application. This initialization does not affect your A5 world either.
EnterMovies initializes everything, including setting up the necessary data space and creating a handle to it. When you’re done, be sure to make a call to ExitMovies to clean up the QuickTime data.
If an application makes multiple calls to EnterMovies, a different set of “globals,” or data area, is set up for each call. A call to ExitMovies should be made before exiting the area that made the call to EnterMovies. For example, an application that uses QuickTime will call EnterMovies and set up the QuickTime world. Then an external may be called upon that wants to use QuickTime. This external would have to make a call to EnterMovies to set up another QuickTime world for its use. Before leaving, the external should call ExitMovies to clean up after itself. The application can then continue to use QuickTime with the original world it set up.
Q Why does the longword at location $0 get changed to 0x40810000 at every trap?
A In System 7, the Process Manager slams a benign value into location $0 to help protect against bus errors when an application inadvertently dereferences a NIL pointer. (There’s no bus-error checking on writes to ROM, so the “benign value” is usually ROMBase+$10000.)
If you’re debugging, you want the opposite effect: you want these inadvertent accesses to “cause” bus errors. If you put a different value in location $0 before the Process Manager starts up (that is, from MacsBug or TMON initialization, or from an INIT like EvenBetterBusError), it will force that value instead. For more information, see the “Macintosh Debugging” article in this issue.
Q I’m filling a large buffer with one SCSIRead call. What happens if the Macintosh runs under System 7 with virtual memory (VM) and parts of my buffer are swapped out?
A Parts of your buffer must not be swapped out. Before calling SCSIGet, you must ensure that all code and buffers accessed while the SCSI bus is busy are held in physical memory. If there isn’t enough real memory to allocate a full buffer, the application must request smaller blocks (if possible) from the SCSI
device, because it’s not possible to swap in and out any buffer space during a single I/O operation. Page faults are not serviced while SCSI I/O is in progress. If SCSI I/O is performed at device driver-level Read or Write calls, VM holds your buffer for you. Otherwise, you are responsible for doing this yourself.
If there is insufficient physical memory for VM to hold your buffers for you, the Read or Write call fails with an error result.
In general, I/O buffer space used by drivers must be held in real memory for the duration of the I/O operation. This is especially true for SCSI I/O because VM uses SCSI to swap virtual memory in and out, and encountering another page fault would cause a bus error. Device Manager-level I/O handles this automatically, by holding down the appropriate memory when the driver is entered through a Read or Write call. The Device Manager does not take care of this for you when the driver is entered through a Control or Status call, however. If the SCSIRead call is made from within a device driver as a result of a PBRead, no special action is necessary. Any other type of code must be very careful not to cause page faults between SCSIGet and SCSIComplete. This requires holding or placing in the system heap any code or data structures referenced during this time.
Q Is there anything special that a Macintosh hard disk or a removable cartridge driver must do to be fully compatible with System 7?
A One important thing you should be aware of regarding removable cartridges is that a cartridge can’t be removable if VM is to use it for a backing store. Some removables allow you to fix this with a SCSI command to prohibit ejection and, just as important, the drive must be marked nonejectable in the drive queue.
Here are a couple of suggestions: Read Macintosh Technical Note #285, “Coping with VM and Memory Mappings.” Also, take a look at the Memory Management chapter of Inside Macintosh Volume VI and the Virtual Memory paper (Goodies:VM Goodies:VM Paper) on the System 7 Golden Master CD.
Q What does the “!” mean when I use the MacsBug Heap Zone (HZ) command?
It appears in front of one of the zone names listed, or just after the address if the zone doesn’t have a name.
A MacsBug’s HZ command does a quick-and-dirty heap check, and if it thinks something is wrong with a heap, it puts the exclamation point after the address range of the heap. If you select the heap flagged with a “!” with the Heap Exchange (HX) command and then use the regular Heap Check (HC) command, MacsBug tells you what it thinks is wrong with that heap.
Q I want to display only visible files and folders in a Standard File dialog, but I can’t find a way to filter out invisible folders—specifically the 000Move&Rename folder. The FileFilter routine filters only files, not folders. If I put in a nonzero TypeList, invisible folders seem to be removed, but I want to open all types of files, just not invisible files or folders. Any suggestions?
A This is, in fact, impossible under System 6 using general methods. The problem is that passing -1 as numTypes means not only to display all items, but to display invisible items. A file filter can be used to remove the invisible files but cannot affect invisible folders. The only current way to do this is to use CustomGetFile under System 7, as described in the Standard File Package chapter of Inside Macintosh Volume VI. This provides a filter that allows you to filter both files and folders. This will give you the right functionality, but will work only under System 7. We recommend that you use this method under System 7, and a more standard SFGetFile when running under earlier systems.
Q How can I obtain the volume reference information in my DlgHook function for a
file selected by the user before SFPPutFile or SFPGetFile has completed the reply record?
A On exit, SFPGetFile and SFPPutFile generate a working directory reference number in the vRefNum field of the reply record. This is not available to you from within the operation of a DlgHook function. WDRefNums are provided to allow compatibility with older, pre-HFS functions that took vRefNum values of integer size with the older flat file system.
We suggest that, unless you plan to support the flat file system of 64K ROM Macintosh systems, you move your file system interfaces to the HFS interfaces documented in the File Manager sections of Inside Macintosh Volumes IV and V (or to the equivalent high-level calls as documented in Macintosh Technical Note #218, “New High-Level File Manager Calls”). If you’re using the HFS calls, low-memory globals SFSaveDisk and CurDirStore contain, respectively, the negative of the “real” volume reference number for the current volume and the HFS ID of the directory that Standard File is displaying. You then have all the information you need to create, open, rename, or delete files from within the SFPGetFile and SFPPutFile DlgHook functions. If a user is accessing an MFS volume on an HFS system, these calls are designed to handle file access transparently.
Moving your file system interfaces to the HFS-level conventions has a side benefit of being closer to the System 7 file system specifications. If you look at the new high-level file system calls in Inside Macintosh Volume VI, you’ll recognize much of the HFS information embedded in the new data structures.
If your file system interfaces depend on MFS-style vRefNums, or WDRefNums in the HFS nomenclature, you can use the HFS functions PBOpenWD, PBCloseWD, and PBGetWDInfo to open, close, and obtain volume reference numbers and directory IDs. This is particularly important if, for instance, you’re using the THINK C ANSI file I/O functions, which rely on SetVol to operate correctly.
Complete information on the HFS-level calls that will be most useful in Standard File customization is contained in the File Manager chapters of Inside Macintosh Volumes IV and V, and in Macintosh Technical Notes #66, 77, 102, 140, 179, 190, and 218. For C users, Macintosh Technical Note #246 summarizes a list of the difficulties with mixing C file I/O with Macintosh file I/O. Macintosh Technical Notes #47 and 80 discuss a few points of Standard File customization from the point of view of HFS.
Q Why does GetGWorldPixMap (when called on a Macintosh II, IIcx, or IIx running system software version 6.0.5 or 6.0.7 with 32-Bit QuickDraw 1.2) return a combination of the device field (two bytes) and the first two bytes of the portPixMap field? Is this a bug?
A Your analysis of GetGWorldPixMap is exactly right: It doesn’t work correctly in system software version 6.0.5 and 6.0.7 with 32-Bit QuickDraw 1.2. It returns a value that’s two bytes before the value it’s supposed to return.
The solution is to use GWorldPtr->portPixMap instead of GetGWorldPixMap. It’s safe to do this, but you should use GetGWorldPixMap under System 7. Not only is the bug fixed there, but dereferencing the port is dangerous under
System 7 because it may not be CGrafPort. Use Gestalt with the gestaltQuickdrawVersion selector to determine whether you can use GetGWorldPixMap. If Gestalt returns a value from gestalt8BitQD ($0100) through gestalt32BitQD12 ($0220), then GetGWorldPixMap either doesn’t exist or is the buggy version. If it returns gestalt32BitQD13 ($0230) or higher, then GetGWorldPixMap does exist and works correctly. Interestingly, GetGWorldPixMap can be called on a black-and-white QuickDraw machine under System 7. It returns a handle to a structure which should be treated as a BitMap structure, though there are some undocumented fields after the normal BitMap fields. To tell whether GetGWorldPixMap is available on a black-and-white QuickDraw machine, you must check the system software version by calling Gestalt with the gestaltSystemVersion selector. If it returns $0700 or higher, GetGWorldPixMap is available.
Q DrawText with srcCopy takes six times as long as with srcOr now that my Macintosh is running System 7. Why is this so slow? Is this a bug in System 7?
A It’s true that srcCopy is slower than srcOr when handling text, especially in color mode. This loss in speed occurs because CopyBits is a lot smarter than it used to be. It can handle foreground and background colors a lot better, but that improvement came at the cost of speed. Our recommended method for drawing text is to erase before drawing, and use srcOr to draw, not srcCopy. Alternatively, you could draw colorized text in srcOr mode off screen and then use CopyBits to draw it on the screen in srcCopy mode without colorization.
Q I’m creating PICTs that are comprised of many lines drawn in srcOr mode. When using the LaserWriter 6.x or 7.x driver with the Color/Grayscale radio button selected, some lines fail to print. Why is this happening?
A The problem is a bug in the LaserWriter driver. Sometimes, when using a CGrafPort, the driver doesn’t reproduce lines drawn in srcOr mode.
(A CGrafPort is used when the Color/Grayscale print option is selected; in Black & White print mode, a regular grafPort is used.) A workaround is to use srcCopy instead of srcOr when drawing QuickDraw objects within your PICTs.
Q Is there any way to determine whether I’m printing to either a color printer or a printer simulating color, such as the LaserWriter set for Color/Grayscale?
A Check the grafPort returned by your call to PrOpenDoc. If the rowBytes of the grafPort is less than 0, the Printing Manager has returned a color grafPort. You can then make Color QuickDraw calls into this grafPort. LaserWriter driver version 6.0 and later returns a color grafPort from the PrOpenDoc call, if the Color/Grayscale button has been set.
The following code fragment demonstrates this:
(* This function determines whether the port passed to it is a *)
(* color port. If so, it returns TRUE. *)
FUNCTION IsColorPort(portInQuestion: GrafPtr): BOOLEAN;
BEGIN
IF portInQuestion^.portBits.rowBytes < 0 THEN
IsColorPort := TRUE
ELSE
IsColorPort := FALSE;
END;
A third-party printer driver should return the type of grafPort that represents the abilities of its printer. Therefore, if the printer supports color and/or grayscale, and if Color QuickDraw is present, the application will receive a color grafPort after calling PrOpenDoc. Otherwise, if the Macintosh you’re
running on does not support Color QuickDraw, you should return a black-and-white grafPort.
Q If I use the PostScriptHandle PicComment to send PostScript code to the LaserWriter driver, do I need to open a picture and then draw the picture to the driver, or can I just use the PicComment with no picture open while drawing to the printer’s grafPort?
A You don’t need to create a picture with your PicComment in it and draw the picture to the driver. The best method for sending PostScript code to the LaserWriter is to use the PostScriptHandle PicComment documented in Macintosh Technical Note #91, “Optimizing for the LaserWriter—Picture Comments,” as shown below.
PrOpenPage(...)
{ Send some QuickDraw so that the Printing Manager gets a }
The above code prints a line on any type of printer, PostScript or not. The first MoveTo/LineTo combination is required to give the LaserWriter driver a chance to define a clipping region. The LaserWriter driver replaces the grafProcs record in the grafPort returned from PrOpenDoc. In order for the LaserWriter driver to get execution time, you must execute a QuickDraw drawing routine that calls one of the grafProcs. In this case, the MoveTo/LineTo combination calls the StdLine grafProc. When StdLine executes, it notices that the grafPort has been reinitialized, and therefore initializes the clipping region for the port. Until the MoveTo/LineTo combination is executed, the clipping region for the port is set to (0,0,0,0). If PostScript code is sent via the PostScriptHandle PicComment before executing any QuickDraw routines, all PostScript operations will be clipped to (0,0,0,0).
The next thing that’s done is to send the PostScriptBegin PicComment. This comment is recognized only by PostScript printer drivers. When the driver receives this comment, it saves the current state of the PostScript device (by executing the PostScript gsave operator), then disables all QuickDraw drawing operations. This way, the QuickDraw representation of the graphic will be ignored by PostScript devices. In the above example, the second MoveTo/LineTo combination is executed only on non-PostScript devices.
The next PicComment is PostScriptHandle, which tells the driver that the data in thePSHandle is to be sent to the device as PostScript code. The driver then passes this code unchanged to the PostScript device for execution. The PostScriptHandle comment is recognized only by PostScript printer drivers.
The last PicComment, PostScriptEnd, tells the driver to restore the previous state of the device (via a PostScript grestore call), and to enable QuickDraw drawing operations.
Since most PicComments are ignored by QuickDraw devices, only the QuickDraw representation is printed. Since PostScriptBegin tells PostScript drivers to ignore QuickDraw operations, only the PostScript representation is printed on PostScript devices. This is a truly device-independent method for providing both PostScript and QuickDraw representations of a document.
Q How do users install the Macintosh Communications Toolbox (CTB)?
A The Communications Toolbox consists of two parts: the CTB managers and the CTB tools. The installation procedure for CTB tools is different between
System 6 and System 7. Under System 6 the CTB tools are dragged from the Basic Connectivity Set disk to the Communications Folder in the System Folder on the hard disk. Under System 7 the CTB tools are dragged from the Basic Connectivity Set disk to the Extensions folder in the System Folder on the hard disk. Of course, because of the way System 7 works, CTB tools can simply be dragged to the System Folder and the Finder will automatically move them to the Extensions folder where they belong.
No installation of the CTB managers is required under System 7, since System 7 includes the Communications Toolbox as part of the system. Users running System 6.0.5 should use the Installer and Install script on the Communications 1 disk to install the CTB managers and other resources onto their hard disks. Users running System 6.0.7 should use the Installer and Install script on the Network Products Installer disk, which is part of the System 6.0.7 set users receive with their Macintosh systems. The Network Products Installer disk does not contain the CTB managers and other resources, but it prompts the user to insert the Communications 1 disk during the installation procedure.
The Basic Connectivity Set and Communications 1 disks should be shipped with your CTB-aware product. Contact Apple’s Software Licensing group (AppleLink SW.LICENSE) for a licensing agreement to ship the disks.
Q Can any AppleTalk routines be called at interrupt time? Inside Macintosh says that DDPWrite and DDPRead can’t be called from interrupts. If all higher-level AppleTalk protocols are based on DDP, it seems that they all would not work.
A The AppleTalk routines you can’t call at interrupt time are the original AppleTalk Pascal Interfaces listed in Inside Macintosh Volume II; these are also known as the “Alternate Interface” AppleTalk routines, or ABPasIntf.
The Alternate Interface routines cannot be called at interrupt time because they allocate the memory structures needed to make the equivalent assembly language AppleTalk call. For example, when the NBPLookup routine is called, it’s passed a handle to an ABusRecord. NBPLookup then has to allocate an MPPParamBlock and move the parameters from the ABusRecord into the newly allocated MPPParamBlock. Then NBPLookup makes a LookupName call, passing it the MPPParamBlock. When LookupName completes, NBPLookup must move results into the ABusRecord and release the memory used by the MPPParamBlock. Since memory is allocated and released within the routine, it cannot be called at interrupt time.
With that out of the way, the calls you can make at interrupt time (with some restrictions listed below) are what Apple calls the “Preferred Interface” AppleTalk routines. Most of the Preferred Interface routines are listed on page 562 of Inside Macintosh Volume V. There are a few additional calls that were added after the publication of Inside Macintosh Volume V; they’re documented in the AppleTalk chapter of Inside Macintosh Volume VI.
The Preferred Interface AppleTalk routines can be made at interrupt time as long as:
• You make them asynchronously with a completion routine (that is, the asynch parameter must be TRUE and you must provide a pointer to the completion routine in the ioCompletion field of the call’s parameter block). Making a call asynchronously and polling ioResult immediately afterward within the same interrupt-time code (which is basically the same as making the call synchronously) is not the same as using a completion routine.
• They are not listed as routines that may move or purge memory. The Preferred Interface routines do not allocate or dispose of any memory, since they’re just high-level ways to make the assembly language AppleTalk calls and are not built upon the old Alternate Interface routines.
Q Why do I get only the left channel of a stereo sound out of my Macintosh IIcx?
A The only Macintosh models that combine the two stereo channels into one for playback out of the internal speaker are the Macintosh SE/30 and the IIsi.
All others use just the left channel. If you would like to check for the machine’s ability to do mixing, you can use Gestalt. This is documented in Inside Macintosh Volume VI, page 22-70. Bit 1 of the Gestalt selector for sound will tell you whether the machine has stereo mixing on the internal speaker.
Q Inside Macintosh Volume VI, page 2-22, recommends updating the window positions in a file without changing the last modification date and time on the file. How do I alter a file without automatically changing the timestamp?
A To modify the contents of a file’s data or resource fork without changing the last modified date, get the modified date before performing any save operations on the file and restore it when you’re done. You can use the PBHGetFInfo and PBHSetFInfo calls to do this. A short Pascal snippet that modifies the contents of a known file’s resource fork without modifying its modification date is included in the Snippets folder on this issue’s Developer CD Series disc. The code shows how the parameter block is filled in with the file’s information at the start of the routine with a PBHGetFInfo call, and the same data is then used without modification to set the file information at the end of the routine with a PBHSetFInfo. Inside Macintosh Volume IV, page 150, tells you which fields can be changed with PBHSetFInfo.
Q Help! I’ve just added Balloon Help to my application, but I’m having some problems. Whenever a balloon appears, it immediately begins floating away off the top of the screen. What can I do to stop this madness?
A It appears you failed to heed our warning when it comes to routines that can move balloons. Consult Appendix D of Inside Macintosh X-Ref, “Routines That May Pop Balloons or Cause Barometric Disturbances,” for a complete listing of these help balloon meteorological nightmares. In addition, be sure to call the new trap HMSetBalloonContents:
with balloonContents set to something greater than helium.
APPLE II Q & A
Q How can I “dim” text in my Apple IIGS application, similar to the way the Toolbox dims menu titles and menu options, and the way that HiliteControl dims a button name?
A Dimming text is a piece of cake. Here’s how the Apple IIGS Menu Manager does it in both 640 and 320 mode. The same thing works great for both.
1. Calculate the bounding box of the text.
2. Fill it with the proper background color for the operation in question.
3. Draw the text.
4. Execute code that looks something like this:
pea dimmed>>16
pea dimmed
_SetPenMask ;Set the pen mask to "dimmed" mask
pea textRect>>16
pea textRect ;Push pointer to text boundary rect
lda backColor ;Get text's background color
and #$00FF ;Always solid
; Here you need to do something in your code to get the
; appropriate pattern for the text you're drawing. This will be
; one of the 16 patterns in the 512-byte table, starting with 16
; bytes of $00, 16 bytes of $11, and ending with 16 bytes of $FF.
; We leave the routine GetColorPtr for you to code, but our
; example assumes it returns the pointer we need in A (low word)
; and X (high word).
jsr GetColorPtr ;(see above)
phx ;high word
pha ;low word
_FillRect ;Fill will be dithered
pea nor_mask>>16 ;Reset drawing mask to normal solid
pea nor_mask
_SetPenMask
rts
textRect DC.B $00,00,00,00 ;Put your rectangle here
backColor DC.W $0000 ;Background color of text to dim
dimmed DC.B $55,$AA,$55,$AA,$55,$AA,$55,$AA
nor_mask DC.B $FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
Yes, it’s really this easy!
Q When I call FixFontMenu from my Apple IIGS new desk accessory (NDA), everything works fine, but if the current application has a font menu it stops working. What’s wrong?
A FixFontMenu keeps only one correspondence between menu item IDs and font family numbers—if you call FixFontMenu from an NDA, you blow away the already existing correspondence that the application was using, maintained within the Font Manager. ItemID2FamNum then works only on item IDs corresponding to your NDA’s font menu, and these usually are unrelated to the values the application passes from its font menu. Worse, FamNum2ItemID will subsequently return menu item IDs for font family numbers that have nothing to do with the application’s menus; depending on how the application operates on the resulting item ID, this could be disastrous.
Fortunately, doing this yourself is fairly easy with the Font Manager’s help. CountFamilies tells you how many font families there are, and FindFamily returns the name of each of them. You can manipulate this information into a font menu in a fairly straightforward way, using standard Menu Manager calls. While you’re at it, you can also use FindFontStats to figure out what point sizes and styles are available for each font family, so you can indicate this in your Size and Style menus. You could even use the information to build your own font-choosing dialog, much as HyperCard IIGS does. Remember that your NDA should run in either 320 or 640 mode, so don’t make the dialog box too wide.
Q When using an Apple IIGS run queue item, can I use the second reserved field to find out when the item was last executed? I assume this value is the tickCount. Currently, I just get the current tickCount and subtract the last tickCount. Using this field could save me one tool call, and when doing animation via a RunQ, every extra tick counts.
A No, you should not use undocumented fields in the run queue header because they could change with future software releases. However, there is a fast way to get the current tick count. Pass refNum $0005 to the GetAddr function in the Miscellaneous Tools once each time your program runs, and it tells you the location of the tick counter. Since the tick count changes during heartbeat interrupts, be sure to disable interrupts around your direct accesses to the tick counter (PHP, SEI, access tick count, PLP).
If your application makes certain tool calls frequently, it may be worthwhile to short-circuit the tool dispatcher and transfer control to the Toolbox function directly (if the tool takes a long time to execute anyway, it isn’t worth it). You can get a function’s address and work area pointer by calling GetFuncPtr and GetWAP in the Tool Locator. When the function gets control, the Y and A registers must contain the tool set’s work area pointer, the X register must
contain the function number, and there must be two RTL addresses on the
stack.
Q Does the Apple IIe Card for the Macintosh LC have a technical reference manual?
A There’s no separate technical reference manual. Use the Apple IIe Technical Reference (Addison-Wesley), together with Apple IIe Technical Note #10, “The Apple IIe Card for the Macintosh LC.”
Q What’s the proper method of saving the Apple IIGS Super Hi-Res (SHR) screens? If my application both uses shadowing and is fast-port aware, the restored screen colors are garbaged. Can I simply use HandToPtr with ptr representing the screen addresses, or will this mess up the scan-line control byte (SCB) restoration since these are read-modify-write locations?
A The shadowed screen’s SCBs may not be correct, so by saving and restoring them you’re causing random data to be restored into the standard SCBs. Your best bet, if shadowing is on, is to turn shadowing off, restore the bank $01 screen, including its SCBs and color tables, turn shadowing on, and restore the $E1 screen and contents. If you don’t want to double-restore the $E1 screen and $01 screen, you should turn shadowing off, restore the bank $01 color tables/SCBs, turn shadowing on, and restore the $01 screen. But, since these screens are never guaranteed to be the same when you save, you should always restore both screens separately.
QuickDraw never touches the shadowed screen SCBs, so if the fastPort flag is set you can ignore the restoring of the bank $01 SCBs/color tables, since the application promised not to interfere with them. But since this won’t save very much time, you probably shouldn’t worry about it.
Q I am using an Apple IIGS utility to generate resources for my application, and I noticed that some of the resource IDs generated are in the range $07FF0000 to $07FFFFFF, which is reserved for the system software’s use. What’s happening?
A Your utility is calling UniqueResourceID with an IDRange of $FFFF, to request any unused resource ID. A bug in system software version 5.0.x allows UniqueResourceID to accidentally return a system-range resource ID if any system-range resources of that type are already present. This will be fixed in System 6. In the meantime, utilities can use UniqueResourceID with IDRange values other than $FFFF, and you should watch your resource IDs carefully to avoid using system-range resource IDs.
BE OUR GUEST
GWORLDS AND NUBUS MEMORY
FORREST TANAKA AND
PAUL SNIVELY
In Developer Technical Support, we’re asked from time to time how to make a GWorld so that its pixel image uses memory on a NuBus™ card rather than memory in the application’s heap. The idea is to create a GWorld, put the address of the card into the GWorld, use QuickDraw to draw into the GWorld, which effectively draws into the NuBus card’s memory, and display the resulting image on the screen. Doing this in a way that works well with the 8•24 GC version of QuickDraw and with whatever QuickDraw brews up in the future isn’t possible without breaking a few guidelines. We’ll talk about the reasons for this and what you can do instead. For the more cavalier among you, we’ll also talk about the least offensive method of coercing a GWorld so that it uses memory on your NuBus card.
NewGWorld allocates off-screen buffers simply by using the same Memory Manager calls that you can make. To allocate the memory, NewGWorld simply calls NewHandle to allocate the buffer in your application’s heap unless you have the useTempMem bit set, in which case it allocates the buffer in temporary memory. It then tries to move the buffer as high in your heap as possible by calling MoveHHi. That’s really all there is to it. The GWorld’s pixMap, GDevice, and CGrafPort are allocated similarly— they’re all allocated in your heap using regular Memory Manager calls with no special options, patches, or other nefarious tricks. None of this changes when you have the 8•24 GC software active—all memory is still allocated out of your application’s heap. Once you start drawing into the GWorld, though, the GC software can copy the parts of the GWorld to the 8•24 GC memory. The GWorld and its parts still occupy your heap’s memory though, regardless of whether it’s cached on the 8•24 GC card.
If you have a NuBus card with gobs of memory, NewGWorld can’t take advantage of it because the Memory Manager calls that it uses can’t allocate memory on NuBus memory cards. There are no options to NewGWorld or any other GWorld calls that let you say, “There’s lots of memory over on this NuBus card, all for you.” While GWorlds are absolutely fantastic for creating off-screen drawing environments for most of the usual kinds of situations, they’re just not appropriate if you want complete control over where or how the parts of a GWorld are allocated.
QuickDraw is the only thing that’s supposed to know how GWorlds are constructed. We know that they’re CGrafPorts and we can get their pixMap, GDevice, and off-screen buffer, but we shouldn’t make any assumptions about how they were allocated and where they are. For example, we know that the off-screen buffer is allocated as a handle now, but that won’t necessarily be the case in the future. There’s no guaranteed way to tell which way it was allocated, or even if NewGWorld uses the Memory Manager to allocate it at all (which it always does currently, of course). Even the GWorld’s CGrafPort is allocated as a handle that just happens to be always locked. If you try to dispose of a GWorld in which you’ve modified the baseAddr, you’ll need DisposeGWorld to make sure everything is deallocated properly, but its behavior is undefined when it tries to deallocate the off-screen buffer.
So if you want to use the memory on your NuBus memory card and feel comfortable that you’re not relying on something that could change, you’re going
to have to create your own off-screen drawing environment by creating an off-screen pixMap, a color table if your off-screen drawing environment uses indexed colors, a GDevice, and a CGrafPort.
The April 1989 edition of Macintosh Technical Note #120, “Drawing Into an Off-Screen Pixel Map,” covers creating your own off-screen pixMap, CGrafPort, and color table, but it requires you to have the same depth and the equivalent color table that the screen has, so it just steals a screen’s GDevice. We think it’s always a good idea to create your own GDevice when you draw off screen. If you use a screen’s GDevice for drawing off screen, you have to depend on that GDevice’s depth and color table. By creating your own GDevice, your off-screen drawing environment can use any depth and color table you want at any time and still be insulated from whatever changes the user makes with the Monitors control panel.
To create your own GDevice, it’s better not to use NewGDevice because it always creates the GDevice in the system heap; it’s better to keep your data structures in your own heap so that they don’t get orphaned if your application quits unexpectedly and that precious system heap space is preserved. Here’s what you should set each of your GDevice’s fields to be:
gdRefNum Your GDevice has no driver, so just set this to 0.
gdID It doesn’t matter what you set this to; you might as well set it to 0.
gdType Set to 2 if your off-screen pixMap uses direct colors (16 or 32 bits per pixel) or 0 if it uses a color table (1 through 8 bits per pixel).
gdITable Allocate a small (maybe just 2-byte) handle for this field. After you’re done setting up this GDevice and your off-screen pixMap, color table (if any), and CGrafPort, set this GDevice as the current GDevice by calling SetGDevice, and then call MakeITable, passing it nil for both the color table and inverse table parameters, and 0 for the preferred inverse table resolution.
gdResPref We reckon that more than 99.9% of all inverse tables out there have a resolution of 4. Unless you have some reason not to, we’d recommend the same here.
gdSearchProc Set to nil. Use AddSearch if you want to use a SearchProc.
gdCompProc Set to nil. Use AddComp if you want to use a CompProc.
gdFlags Set to 0 initially, and then use SetDeviceAttribute after you’ve set up the rest of this GDevice.
gdPMap Set to be a handle to your off-screen pixMap.
gdRefCon Set to whatever you want.
gdNextGD Set to nil.
gdRect Set to be equal to your off-screen pixMap’s bounds.
gdMode Set to -1. Why? We’re not sure. This is intended for GDevices with drivers anyway.
gdCCBytes Set to 0.
gdCCDepth Set to 0.
gdCCXData Set to 0.
gdCCXMask Set to 0.
gdReserved Set to 0.
For gdFlags, you should use SetDeviceAttribute to set the noDriver bit. You should also set the gDevType bit to 1 if you’re using two bits per pixel or more, but it can be left at 0 if you’re using only one bit per pixel.
The other big difference from the technique shown in Technical Note #120 is that the off-screen pixel image shouldn’t be allocated. Instead, just point the baseAddr field of your off-screen pixMap at your NuBus card’s
memory. You should also set the pmVersion field of your off-screen pixMap to be the constant baseAddr32 (equal to 4). That tells Color QuickDraw to use 32-bit addressing mode to access your off-screen buffer, and that’s a requirement if your off-screen pixel image is located on a NuBus card.
When you want to draw into your off-screen pixMap, save the current port with a call to GetPort and the current GDevice with a call to GetGDevice. Then set the current port to the off-screen CGrafPort with a call to SetPort, and set the current GDevice to the off-screen GDevice with a call to SetGDevice. Now all QuickDraw commands are drawn off screen and the resulting images are in your NuBus card’s memory. To switch back to drawing on screen, set the current port and GDevice back to the port and GDevice that you saved earlier. Easy!
Even with all this, there might still be a reason to use GWorlds to draw into a NuBus memory card. You might just want some quick and dirty way to get an off-screen drawing environment that uses your NuBus memory card and don’t care whether it works with future system software releases or not. We’ll talk about that next and also discuss the issues that you have to be careful about when you do this.
First, create a GWorld using NewGWorld as usual. If you want to, pass it a color table, or you can just pass it nil if you want it to make the default color table. For the GWorld flags, make sure you pass only the keepLocal flag. This makes sure that all the pieces of the GWorld are kept in your own heap rather than being cached into the 8•24 GC card, even when you draw into it. That way, you avoid running into any conceivable conflicts with GC QuickDraw over where the GWorld really is. There’s no way to tell NewGWorld not to allocate the pixel image, so you might want to make the bounds rectangle small and then make it bigger later so that your heap isn’t hit up for a lot of memory that you don’t even want. Don’t pass it an empty rectangle because NewGWorld just gives you a paramErr in that case. Call GetGWorldDevice to get a handle to your GWorld’s GDevice and save it for later.
Now it’s time to have the new GWorld use your NuBus card’s memory. The baseAddr of your GWorld’s pixMap is allocated as a handle, and it has to be thrown out. Call GetPixBaseAddr with a handle to your GWorld’s pixMap to get a pointer to the pixel image that NewGWorld allocated for you. Call RecoverHandle with that pointer to get a handle to the pixel image, and then call DisposHandle to get rid of it. Now put the address of your NuBus board into the baseAddr of your GWorld’s pixMap. Then set the pmVersion field of your GWorld’s pixMap to the constant baseAddr32. That tells Color QuickDraw that the baseAddr of the pixMap is a 32-bit address and so it should switch to 32-bit addressing mode whenever it draws into your GWorld.
If you passed NewGWorld a rectangle that’s smaller than you actually want, you can now set it to the real size. Set the bounds rectangle of your GWorld’s pixMap and the portRect rectangle of your GWorld’s CGrafPort to the rectangle that you really wanted. Also, set the visRgn of the CGrafPort and the gdRect field of your GWorld’s GDevice to that same rectangle. Your GWorld is ready for use!
Now the bad news. Many of the GWorld routines assume that the baseAddr field is either a real handle or a copy of the handle’s master pointer. Because the pointer in the baseAddr field isn’t a master pointer, those routines can crash when they expect one. Setting the pmVersion field doesn’t help in most cases; these routines just assume that the GWorld’s pixel image was allocated by NewGWorld, which is a reasonable assumption. What this implies is that you can no longer call many of the GWorld routines to maintain your GWorld without a risk of crashing. When you call SetGWorld for your GWorld, you should pass it the GWorld’s GDevice instead of nil (that’s why we recommended that you save the GWorld’s GDevice after calling NewGWorld). For safety’s sake, don’t call any of the following:
LockPixels
UnlockPixels
AllowPurgePixels
NoPurgePixels
GetPixelsState
SetPixelsState
UpdateGWorld
GetGWorldDevice
You can call DisposeGWorld because it won’t get hung up trying to deallocate the pixel image on your NuBus card; setting your pmVersion to baseAddr32 makes this possible. Of course, since all these GWorld routines are off limits, almost all the benefits of having a GWorld at all are gone as well.
Another piece of bad news is that this doesn’t take advantage of the speed benefits of using GWorlds with an 8•24 GC card. Most of the speed benefit of using GWorlds with GC QuickDraw is that the GWorld’s pixel image is allocated on the 8•24 GC card itself, and so the image data doesn’t have to take the time to move across NuBus. If your GWorld draws into a NuBus memory card, the image data has to be moved across NuBus, and so that speed benefit is gone.
The last bit of bad news is that even if you follow all of this, you’re still not guaranteed that it will still work in future system software or future video card releases. As we said earlier, this should only be done if you don’t care whether it works on future system software releases or not. The description above breaks a lot of rules: don’t assume that the pixel image is allocated as a handle; don’t set the baseAddr of a GWorld; don’t change the dimensions of a GWorld without UpdateGWorld; and don’t set the pmVersion field of a GWorld. You have your choices when you want to use QuickDraw to draw off screen into the memory of a NuBus video card. You can be safe for future compatibility by creating your own off-screen drawing environment from scratch, or you can modify a GWorld so that it uses your NuBus card’s memory at the risk of breaking on future systems and at the cost of losing most of the benefits of GWorlds. If you choose the first method and you have no existing routines to create off-screen drawing environments, it’s worth it to take a look at Skippy White’s Famous High-Level Off-Screen Map Routines in DTS Sample Code #15 on the Developer CD Series disc. You can see these routines in action in DTS Sample Code #16. These routines are GWorld-like to some extent, except this time you have the great benefit of source code!
REFERENCES
• “About 32-Bit Addressing,” Konstantin Othmer, develop Issue 6, Spring 1991, pp. 36-37.
• “Deaccelerated _CopyBits & 8•24 GC QuickDraw,” Guillermo Ortiz, Macintosh Technical Note #289, January 1991.
• “Drawing Into an Off-Screen Pixel Map,” Jim Friedlander, Rick Blair, and Rich Collyer, Macintosh Technical Note #120, April 1989.
• Inside Macintosh Volume V, Color Manager chapter, Addison-Wesley, 1988.
INDEX A
AddPathsToPict, curves in QuickDraw and 19, 20
AddSegmentToPict, curves in QuickDraw and 19, 20
Alexander, Pete 41
Apple event handler, Macintosh Q & A 82
AppleTalk, Macintosh Q & A 90
Apple IIe Card, Apple II Q & A 94
Apple II Q & A 92–94
applications, hybrid 64–78
asserts, debugging and 61–62
asynchronous I/O 68
A/UX, hybrid applications and 64–78
auxcleanup_fork_pipe 71
auxfgets 71–72
auxfork_pipe 70–71
AUXisRunning, hybrid applications and 69
auxsystem 72
B
Balloon Help, Macintosh Q & A 91
“Be Our Guest” (Tanaka and Snively) 95–98
Bézier curves, working with in QuickDraw 7–27
buffers and SCSIRead, Macintosh Q & A 83–84
C
CantDeselect, date and time entry in MacApp and 30, 34
cards
Apple IIe Card 94
8•24 GC card 95–98
cartridge drivers, removable 84
CGrafPort, GWorlds and NuBus memory and 95–97 checksum $0, debugging and
50–51
cleanupxfcn, UNIX Mail Reader and 73, 76
COFF (Common Object File Format) System V.2 65
collaboration 79–81
color printing, Macintosh Q & A 87–88
Color QuickDraw, Macintosh
Q & A 82
Communications Toolbox (CTB), Macintosh Q & A 89–90
compiler warnings, full 53–54
configuration tests, debugging and 59–61
cooperative multitasking 67
CopyBits, LaserWriter driver 7.0 and 42
CopyDeepMask, LaserWriter driver 7.0 and 41–42
CopyMask, LaserWriter driver 7.0 and 41–42
CTB (Communications Toolbox), Macintosh Q & A 89–90
curves, in QuickDraw 7–27
“Curves Ahead: Working With Curves in QuickDraw” (Reed and Othmer) 7–27
custom Apple events, Macintosh
Q & A 82
D
date entry, validating in MacApp 28–40
datestamp, Macintosh Q & A 91
DDPRead, Macintosh Q & A 90
DDPWrite, Macintosh Q & A 90
Debugger, The 43–63
debugging 43–63
Delete button script, UNIX Mail Reader and 77–78
DeselectCurrentEditText, date and time entry in MacApp and 29
dimming text, Apple II Q & A 92
Discipline, debugging and 51–52
DlgHook, Macintosh Q & A
85–86
DoChoice, date and time entry in MacApp and 39
DoMouseCommand, date and time entry in MacApp and 39–40
DrawPicture, curves in QuickDraw and 18–19
DrawText, Macintosh Q & A
86–87
drivers
cartridge 84
LaserWriter driver 41–42,
87, 88–89
E
Edition Manager events, Macintosh Q & A 82
8•24 GC card, GWorlds and NuBus memory and 95–98
8•24 GC QuickDraw, GWorlds and NuBus memory and 95–98
Entry script, UNIX Mail Reader and 73–74
errAEFail, Macintosh Q & A 82
errAENotHandled, Macintosh Q & A 82
error handling, debugging and
57–59
ErrorToString, date and time entry in MacApp and 35, 36–37
events, Macintosh Q & A 82
ExampleCurve, curves in QuickDraw and 11
Exit script, UNIX Mail Reader and 74–76
F
fgetfxfcn, UNIX Mail Reader and 73, 76
fgetsxfcn, UNIX Mail Reader and 73, 74
FileFilter, Macintosh Q & A 85
files, invisible 85
FillPoly, curves in QuickDraw and 9
$50FFC001, debugging and 45–47
FixFontMenu, Apple II Q & A 93
folders, invisible 85
forkpipexfcn, UNIX Mail Reader and 73, 74
FrameCurve, curves in QuickDraw and 11
FramePath, curves in QuickDraw and 16
freehand curves, working with in QuickDraw 7–27
full compiler and linker warnings, debugging and 53–54
G
GC card, GWorlds and NuBus memory and 95–98
GC QuickDraw, GWorlds and NuBus memory and 95–98
Gestalt, Macintosh Q & A 82
GetGDevice, GWorlds and NuBus memory and 97
GetGWorldDevice, GWorlds and NuBus memory and 97
GetGWorldPixMap, Macintosh Q & A 86
GetPathsBounds, QD Curves and 23
GetPixBaseAddr, GWorlds and NuBus memory and 97
GetPort, GWorlds and NuBus memory and 97
GetRslData, LaserWriter driver 7.0 and 42
global memory, Macintosh Q & A 83
GRiDPAD 79–81
GWorlds
LaserWriter driver 7.0 and
41–42
NuBus memory and 95–98
H
HandleAlertAccepted 34
HandleAlertCancelled 34
HandleInvalidText 34
HandleMouseDown 39
HandleValidText 34–36
HandToPtr, Apple II Q & A 94
heap scramble and purge, debugging and 47–49
Heap Zone (HZ) command, Macintosh Q & A 84
HGetState, debugging and 52
Horwat, Waldemar 48
HSetState, debugging and 52
Huxham, Fred 43
hybrid applications 64–78
HZ (Heap Zone) command, Macintosh Q & A 84
I
“Inside Story of The Debugger, The” (Jasik) 44
invisible files and folders, Macintosh Q & A 85
I/O, asynchronous 68
IsValid, date and time entry in MacApp and 32–36
J, K
Jasik’s debugger 43–63
Jasik, Steve 44
Johnson, Bo3b 43
Johnson, Dave 79
L
LaserWriter
Macintosh Q & A 87–88
curves in QuickDraw and
7–27
LaserWriter driver 41–42
Macintosh Q & A 87,
88–89
leaks, memory 55–57
LibAUX.h, hybrid applications and 69
libaux_sys.o, hybrid applications and 69
LineTo, curves in QuickDraw and 11, 18, 21
linker warnings, full 53–54
LongDateTime, date and time entry in MacApp and 35
M
MacApp, validating date and time entry in 28–40
MacDraw, curves in QuickDraw and 7–27
“Macintosh Debugging: A Weird Journey Into the Belly of the Beast” (Johnson and Huxham) 43–63
“Macintosh Hybrid Applications for A/UX” (Morley) 64–78
Macintosh Q & A 82–91
MacsBug 43–63
Macintosh Q & A 84
mailx, UNIX Mail Reader and 72–78
memFullErr, Macintosh Q & A 82
memory
NuBus 95–98
32-bit memory mode 52
virtual 83–84
memory leaks 55–57
memory protection 54–55
Morley, John 64
MoveHHi, GWorlds and NuBus memory and 95
000Move&Rename folder, Macintosh Q & A 85
Movie Toolbox, Macintosh Q & A 83
MultiFinder
hybrid applications and
66–70
Macintosh Q & A 82
multiple configuration tests, debugging and 59–61
multitasking, hybrid applications and 66–70
N
\n, hybrid applications and 69
NewGDevice, GWorlds and NuBus memory and 96
NewGWorld, GWorlds and NuBus memory and 95, 97
NextPathSegment, curves in QuickDraw and 14
NuBus memory, GWorlds and
95–98
O
OffsetPaths, QD Curves and 23
Old TMON. See TMON
OMF (Object Module Format) 65
Othmer, Konstantin 7
OutlineToPaths, curves in QuickDraw and 22
P
PackControlBits, curves in QuickDraw and 22
PaintPoly, curves in QuickDraw and 9
parametric equations, curves in QuickDraw and 10
ParamText, date and time entry in MacApp and 35, 38
parmErr, Macintosh Q & A 82
paths 9, 13, 17
drawing 8–17
framing 13–17
saving in PICTs 17–21
picPlyClo picture comment, curves in QuickDraw and 18
PICTs
Macintosh Q & A 87
saving paths in 17–21
Plamondon, James 28
PolyBegin picture comment, curves in QuickDraw and 18
PolyIgnore picture comment, curves in QuickDraw and 19
PolySmooth picture comment, curves in QuickDraw and 18, 19
PostScript
Macintosh Q & A 88–89
curves in QuickDraw and
7–27
PostScriptHandle picture comment, Macintosh Q & A
88–89
preemptive multitasking 67
PrepareErrorAlert, date and time entry in MacApp and 34–35, 37–38
PrGeneral, LaserWriter driver 7.0 and 41–42
“Print Hints From Luke & Zz” (Alexander) 41–42
PrOpenDoc, LaserWriter driver 7.0 and 42
“puppet strings,” Macintosh Q & A 82
Q
Q & A
Apple II 92–94
Macintosh 82–91
QD Curves application 23–27
quadratic Béziers, working with in QuickDraw 7–27
QuickDraw
GWorlds and NuBus memory
and 95–98
LaserWriter driver 7.0 and
41–42
Macintosh Q & A 82
working with curves in 7–27
QuickTime
Macintosh Q & A 83
update 6
R
\r, hybrid applications and 69
RecoverHandle, GWorlds and NuBus memory and 97
Reed, Mike 7
resource IDs, Apple II Q & A 94
RunQ, Apple II Q & A 93–94
run queue items, Apple II Q & A 93–94
S
ScalePaths, QD Curves and 23
screens, SHR 94
SCSIRead, Macintosh Q & A
83–84
Selection script, UNIX Mail Reader and 76–77
SetDeviceAttribute, GWorlds and NuBus memory and 96
SetGDevice, GWorlds and NuBus memory and 97
SetGWorld, GWorlds and NuBus memory and 97
SetPort, GWorlds and NuBus memory and 97
SetRsl, LaserWriter driver 7.0 and 42
SFPGetFile, Macintosh Q & A 85–86
SFPPutFile, Macintosh Q & A 85–86
shapes, framing in QuickDraw 17
SHR (Super Hi-Res) screens, Apple II Q & A 94
'SIZE' resource, Macintosh Q & A 82
Snively, Paul 95
SpinCursor, hybrid applications and 70
Standard File dialog, Macintosh Q & A 85
stereo sound, Macintosh Q & A 91
stress error handling 57–59
Super Hi-Res (SHR) screens, Apple II Q & A 94
T
Tanaka, Forrest 95
TargetValidationFailed, MacApp 3.0 and 32
TDateEditText, date and time entry in MacApp and 31, 35–38
TDialogTEView, MacApp 3.0 and 32
TDialogView
MacApp 3.0 and 32
date and time entry in
MacApp and 29, 39
TEditText
MacApp 3.0 and 32
date and time entry in
MacApp and 28–40
TEvtHandler, MacApp 3.0 and 32
32-bit memory mode, debugging and 52
time entry, validating in MacApp 28–40
timestamp, Macintosh Q & A 91
TMON, debugging and 43–63
“TMON, Then and Now” (Horwat) 48
TNumberText, date and time entry in MacApp and 29
token of control 67
trace, debugging and 62–63
TrueType, curves in QuickDraw and 7–27
TTimeEditText, date and time entry in MacApp and 31, 38–39
TValidText, date and time entry in MacApp and 31–33, 35, 36, 38, 39
U
UNIX, hybrid applications and 64–78
Unixcmd, auxsystem and 72
UNIX Mail Reader 72–78
UpdateGWorld, GWorlds and NuBus memory and 98
V
Validate
MacApp 3.0 and 32
date and time entry in
MacApp and 29, 30, 33,
35, 39
“Validating Date and Time Entry in MacApp” (Plamondon)
28–40
ValidationErrorAlert, date and time entry in MacApp and 34
“Veteran Neophyte, The” (Johnson) 79–81
virtual memory (VM), Macintosh Q & A 83–84
volume reference information, Macintosh Q & A 85–86
W
warnings, compiler and linker
53–54
wireless communication 79–81
writexfcn, UNIX Mail Reader and 73, 76
X, Y
XFCNs, UNIX Mail Reader and 72–78
Z
zapping handles, debugging and 50
$0
debugging and 45–47, 50–51
Macintosh Q & A 83
Subscribe to printed develop
Would you like to become one of our many subscribers who like to have a paper copy of develop at their fingertips? Subscribing is easy; just follow these simple instructions:
• If you’d like us to bill you, fill out the form in this file and send it via AppleLink to DEV.SUBS, or print and fill it out, check “Please bill me,” and send it by mail to the address on the reverse.
• If you’ll be paying by credit card, fill out the form and send it via AppleLink to DEV.SUBS, or print and fill it out and mail it to the address on the reverse.
• If you’ll be paying by check, money order, or international money order, print the order form, fill it out, and mail with payment to the address on the reverse.
Don’t send cash. And please use a separate form for each subscriber.
Subscribe & Save 25%
Yes! Send me a year (4 issues) of develop and the Developer CD Series disc for only $30 in the U.S. That’s 25% off the cover price. All other countries $50.
Name:
Company/Institution:
Title:
Street or Post Office Address:
City:
State/Province and Zip Code:
Country:
Telephone:
____ Please bill me. ____ Payment enclosed.
____ VISA ____ MasterCard
Credit card account number:
Credit card expiration date:
______________________________________
Signature/Date (only if sending by postal mail)
Phone orders call 1-800-877-5548 in the U.S.
(815)734-1116 all other countries
Fax orders to (815)734-1127
AppleLink orders to DEV.SUBS
Allow 6–8 weeks for delivery. U.S. subscription price is $30 for 4 issues of develop and the Developer CD Series disc. All other countries $50. For Canadian orders, price includes 7% GST (R100236199). Please make check payable to Apple Computer, Inc., in exact amount in U.S. dollars, and mail to:
develop
Apple Computer, Inc.
P.O. Box 531
Mt. Morris, IL 61054-7858
USA
B1191D
HOW’RE WE DOING?
We’d love to hear how you feel about develop. If you have any questions, suggestions, or even gripes, please don’t keep them to yourself. (Be sure to include your name, company name, address, and phone number.)
Send technical questions about develop to:
Dave Johnson
Apple Computer, Inc.
20525 Mariani Avenue, M/S 75-2B
Cupertino, CA 95014
AppleLink: JOHNSON.DK
Internet: dkj@apple.com
CompuServe: 75300,715
Fax: (408)974-7084
Send editorial suggestions or comments to:
Caroline Rose
Apple Computer, Inc.
20525 Mariani Avenue, M/S 75-2B
Cupertino, CA 95014
AppleLink: CROSE
Internet: crose@applelink.apple.com
Fax: (408)974-7084
WANT TO SUBSCRIBE?
If you’d like to subscribe to develop, please use the subscription form.
BACK ISSUES OF develop . . .
. . . are on the Developer CD Series disc. You can get printed back issues through APDA, or send your request along with $13 per issue in the U.S. (or $20 outside the U.S.) to the address on the subscription form.
Issue 1 Realistic Color for Real-World Applications; All About the Palette Manager; Braving Offscreen Worlds; The Perils of PostScript; Compatibility: Rules of the Road; Debugging Declaration ROMS; Apple II Development Dynamo
Issue 2 Using C++ Objects in a Handle-Based World; Using Objects Safely in Object Pascal; The Secret Life of the Memory Manager; Speed Your Software Development with MacApp; How to Design an Object-Based Application; Unofficial C++ Style Guide; Demystifying the GS/OS Cache
Issue 3 CD-Rom: The Cutting Edge; The Ins and Outs of ISO 9660 and High Sierra; How to Create a Mixed-Partition CD-ROM; Accessing CD-ROM Audio Tracks From Your Application; Surf's Up: Catch the Comm Toolbox Wave; Macintosh Display Card 8•24 GC: The Naked Truth; Meet PrGeneral, the Trap That Makes the Most of Printing
Issue 4 Writing a Device Driver in C++; Polymorphic Code Resources in C++; Inside the Macintosh Coprocessor Platform and A/ROSE; The Perils of PostScript — The Sequel; Driving to Print: An Apple IIGS Printer Driver
Issue 5 (Volume 2, Issue 1) Asynchronous Background Networking on the Macintosh; Scanning From ProDOS; Palette Manager Animation; The Power of Macintosh Common Lisp
Issue 6 Threads on the Macintosh; QuickDraw's CopyBits Procedure: Better Than Ever in System 7.0; MacTCP Cookbook: Constructing Network-Aware
Applications
Issue 7 QuickTime 1.0: “You Oughta Be in Pictures”; Scoring Points With TrueType; Threaded Communications With Futures; Using C++ Objects in a World of Exceptions; The Subspace Manager in System 7.0
RESOURCES
Apple provides a wealth of information, products, and services to assist developers. The Apple Programmers and Developers Association (APDA) and Apple Developer University are open to anyone who wants access to development tools and instruction. Qualified commercial developers in the U.S. and Canada may access additional information and services through the Apple Associates and Partners programs.
The Associates Program, Apple’s mainstream program for commercial developers, is a convenient and cost-effective way to get essential technical and marketing information. This program offers self-help technical support, keeps you up to date with the latest products and technical documentation, and gives you access to the Apple developer community through AppleLink. Associates also receive discounts on equipment. The Associates program is designed for commercial developers.
The Partners Program is open to Apple-selected commercial developers. In addition to receiving the same development information and tools as Associates, Partners receive technical support via electronic mail. Membership in the Partners program is limited to developers who directly contribute to Apple’s long-term product strategies and business objectives. APDA offers convenient worldwide access to development tools, resources, training products, and information for anyone interested in developing applications on Apple platforms. Customers receive the quarterly APDA Tools Catalog featuring over 300 Apple and third-party development products. There are no membership fees. APDA offers convenient payment and shipping options, including site licensing. Apple Associates or Partners automatically receive the APDA Tools Catalog.
Apple Developer University provides training for all levels of Macintosh programmers. The hands-on classes give you experience using the most up-to-date development tools. Classes are offered in locations across the United States and internationally, and on-site instruction can also be arranged. Multimedia self-paced courses are available from Developer University through APDA. These courses include Macintosh Programming Fundamentals, User-Centered Design, and Introduction to Object-Oriented Programming.
±∞ ◊# ˇ ˇˇˇˇ # ◊
d , Helvetica
< . ° d ONLN d ) Ÿ e ˛ +˜vd ° d ONLN d ) e- )3e ° d ONLN d ); e\ )/v ° d ONLN d )j eã )/e ° d ONLN d )ô e™ )/l ° d ONLN d )∏ e› ) o ° d ONLN d )Î e )3p
° d ONLN d e › t Ê ( è ˚T ° d ONLN d e Î t Û )h ° d ONLN d
e ¯ t )
e ° d ONLN d e t )
° d ONLN d e
t )A ° d ONLN d
e t# )p ° d ONLN d e( t0 )
p ° d ONLN d e5 t8 )
l ° d ONLN d e= tE )e ° d ONLN d eJ tM )
° d ONLN d eR t[ )T ° d ONLN d e` th )e ° d ONLN d em tt )
c ° d ONLN d ey tÅ ) h ° d ONLN d eÜ té )
n ° d ONLN d eì tñ )
i ° d ONLN d eõ t¢ )c ° d ONLN d eß tØ ) a ° d ONLN d e¥ t∑ )
l ° d ONLN d eº tø ) ° d ONLN d eƒ t )J ° d ONLN d eœ t◊ ) o ° d ONLN d e‹ t‰ )
CURVES AHEAD: ° d ONLN d 3 Œ8 €£ * WORKING WITH ° d ONLN d @ fi8 ÎÑ * CURVES IN ° d ONLN d J Ó8 ˚é * QUICKDRAW ° d ONLN d T 8≤ * VALIDATING DATE ° d ONLN d d8(º *AND TIME ENTRY IN ° d ONLN d v+88q *MACAPP ° d ONLN d }H8Uã * MACINTOSH ° d ONLN d áX8eü * DEBUGGING: A ° d ONLN d îh8u´ *
WEIRD JOURNEY ° d ONLN d ¢x8Öæ *INTO THE BELLY OF ° d ONLN d ¥à8ïÖ * THE BEAST ° d ONLN d æ•8≤√ * MACINTOSH HYBRID ° d ONLN d œµ8¬æ *APPLICATIONS FOR ° d ONLN d ‡≈8“W *A/UX ° d ONLN d ‚8Ôâ * COPYMASK, ° d ONLN d ÔÚ8ˇÆ *
COPYDEEPMASK, ° d ONLN d ˝8Ω *AND LASERWRITER ° d ONLN d
8 Ç *
DRIVER 7.0 ° d ONLN d/8<¢ * GWORLDS AND ° d ONLN d$?8L™ * NUBUS MEMORY ° d ONLN d1\8i¥ * MACINTOSH Q & A ° d ONLN dAy8Üô * APPLE II Q & A
° d ONLN dPö8≥M *+
° d ONLN dR≥8¡< *I ° d ONLN dS≥=¡g )ssue 8
° d ONLN dY¥g¿p )* ° d ONLN d\¥p¿Æ ) Autumn 1991 ˇO» ◊# ˇ ˇˇˇˇ # ◊
d , Helvetica
. ° d ONLN d Ü ñ ë +¥≠ E D I T O R I A L S T A F F , Palatino ° d ONLN d ï ñ û ⁄ *Editor-in-Cheek ° d ONLN d . ï ⁄ û )D
Caroline Rose ° d ONLN d < £ ñ ¨ ‘ ( … ¥Spirited Guide ° d ONLN d L £ ‘ ¨ )>Louella Pizzuti ° d ONLN d \ ± ñ ∫ ı ( ◊ ¥Technical Buckstopper ° d ONLN d s ± ı ∫) )_ Dave Johnson ° d ONLN d Ä ø ñ » ” ( Â ¥Review Board ° d ONLN d é ø ” »G )= Pete “Luke” Alexander, Chris ° d ONLN d ¨ Õ ° ÷4 ( Û ø&Derossi, C. K. Haun, Larry Rosenstein, ° d ONLN d ’ € ° ‰2 *!Andy Shebanow, and Gregg Williams ° d ONLN d ˜ È ñ Ú fi ( ¥Managing Editor ° d ONLN d È fi Ú )HMonica Meffert ° d ONLN d ˜ ñ Ì ( ¥Contributing Editors ° d ONLN d- ˜ Ì 8 )WLorraine Anderson, ° d ONLN dA °C (+ ø*Geta Carlson, Toni Haskell, Judy Helfand, ° d ONLN dl ° * *"Rilla Reynolds, and Carol Westberg ° d ONLN dè! ñ* ∏ (G ¥ Indexer ° d ONLN dò! ∏* Î )"
Printing ° d ONLN dóü ∫®1 )$ Wolfer Printing Company, Inc. ° d ONLN dµ≠ ñ∂ › (” ¥Film Preparation ° d ONLN d«≠ ›∂ )GAptos Post, Inc. ° d ONLN dÿª ñƒ Δ (· ¥ Production ° d ONLN d‰ª Δƒ )0PrePress Assembly ° d ONLN dˆ… ñ“ Õ (Ô ¥
Photography ° d ONLN d… Õ“< )7 Sharon Beals, Ralph Portillo, ° d ONLN d"◊ °‡ ı (˝ øand Steven C. Johnson ° d ONLN d8 ñÓ ¸ ( ¥Circulation Management ° d ONLN dP ¸Ó2 )f David Wilson ° d ONLN d]Û ñ¸ „ ( ¥Online Production ° d ONLN dpÛ „¸! )MCassi Carpenter 0 °z/Ó
d ° d ONLN dÇ\$Ù (Az#This sinuous cover artwork was made ° d ONLN d¶'\0˚ * 'possible by quadratic Bézier curves and ° d ONLN dŒ3\<ı * $TrueType, and was created by Rucker- ° d ONLN dÛ?\HÊ * #Huggins (initial studies by Corinne ° d ONLN dK\T * !Okada; final arrangements by Cleo ° d ONLN d9W\`Ó * %Huggins) using Adobe Illustrator 3.0. ° d ONLN d_u\~á *
. ° d ONLN d " 2 ) +<ME ° d ONLN d " , 2 8 )D ° d ONLN d " ; 2 ? )I ° d ONLN d " B 2 J )T ° d ONLN d " M 2 Z ) O ° d ONLN d " ] 2 i )R ° d ONLN d " l 2 p )I ° d ONLN d " s 2 ~ )A ° d ONLN d " Å 2 ä )L , Palatino
° d ONLN d
% ü 1X ) +On-line reading versus on-line reference
° d ONLN d 5 &X 1^ )π2
° d ONLN d 8 ; 1 K : ( f OL ° d ONLN d 9 ; = K H ) E ° d ONLN d : ; K K S )T ° d ONLN d ; ; V K ^ ) T ° d ONLN d < ; a K l ) E ° d ONLN d = ; o K { )R ° d ONLN d > ; ~ K ä )S
° d ONLN d @ > ü JD )!'Your letters to us. Keep ’em coming!
° d ONLN d g ?D JJ )•4
° d ONLN d j T & d 1 ( DA ° d ONLN d k T 4 d @ )R ° d ONLN d l T C d K )T ° d ONLN d m T N d R ) I ° d ONLN d n T U d a )C ° d ONLN d o T d d m )L ° d ONLN d p T p d { ) E ° d ONLN d q T ~ d ä )S
° d ONLN d s W ü c± )!0Curves Ahead: Working With Curves in QuickDraw
° d ONLN d £ X± c ( œby Mike Reed and ° d ONLN d ¥ e ü p ¸ ( å ΩKonstantin Othmer
° d ONLN d ≈ d ¸ p )] ° d ONLN d » d pÔ ) 3All about quadratic Bézier curves on the Macintosh, ° d ONLN d ¸ q ü }w ( ô Ω2including using the curves from TrueType fonts.
° d ONLN d. rw }} )ÿ7
° d ONLN d2 ä ü ñÜ ( ≤ Ω*Validating Date and Time Entry in MacApp
° d ONLN d\ ãÜ ñÓ )Áby James Plamondon
° d ONLN dq ó ü £ ( ø ΩMHere’s a new MacApp class that provides robust and flexible entry validation.
° d ONLN d¡ • ü ∞ ´ *
28
° d ONLN dΔ Ω ü … *@Macintosh Debugging: A Weird Journey Into the Belly of the Beast
° d ONLN d À ü ÷L *
by Bo3b Johnson and Fred Huxham
° d ONLN d' L ÷U )≠ ° d ONLN d* U ÷˛ ) &This article presents some very useful ° d ONLN dQ ◊ ü „˜ ( ˇ ΩKdebugging techniques that every Macintosh developer needs to know about.
° d ONLN dú ÿ˜ „ ( ˇ43
° d ONLN d° ü ¸x ( Ω(Macintosh Hybrid Applications for A/UX
° d ONLN d… Òx ¸√ )Ÿby John Morley
° d ONLN d◊ √ ¸Δ )K ° d ONLN dÿ Δ ¸ ) ° d ONLN d⁄ ¸ˆ )
This is an ° d ONLN d ˝ ü Ë (% ΩGintroduction to writing Macintosh applications meant to run under A/UX, ° d ONLN d-
üπ *
?explaining the basics and pointing out some potential gotchas. ° d ONLN dl
πΩ (2◊
° d ONLN dn Ω… )64
° d ONLN dr '0 3 (K EC ° d ONLN ds 60 C )O ° d ONLN dt F0 O )L ° d ONLN du R0 ] ) U ° d ONLN dv `0 m )M ° d ONLN dw p0 { )N ° d ONLN dx ~0 ä )S
° d ONLN dz# ü/„ )!7Print Hints From Luke & Zz: CopyMask, CopyDeepMask, and ° d ONLN d≤0 ü< *
LaserWriter Driver 7.0
° d ONLN d 1<ô )|by Pete “Luke” Alexander
° d ONLN d‚0ô<¢ )~ ° d ONLN dÂ0¢< ) How do you print ° d ONLN dˆ= üI (e ΩHgraphics that use CopyMask and CopyDeepMask with LaserWriter driver 7.0? ° d ONLN d?J üV& *
Read this column to find out.
° d ONLN d_K&V2 )á41
° d ONLN ddc üoâ (ã Ω)The Veteran Neophyte: Don’t Fence Me In
° d ONLN dçdâofi )Íby Dave Johnson
° d ONLN dúcfioÁ )U ° d ONLN dücÁo ) Dave ° d ONLN d§p ü|Ù (ò ΩIwaxes philosophical about wirelessness, collaboration, communication, and ° d ONLN dÓ} üâ ‰ *
buffalo heels.
° d ONLN dˇ~ ‰â )E79
° d ONLN dñ ü¢ç (æ Ω(Be Our Guest: GWorlds and NuBus Memory
° d ONLN d,ó碸 )Óby Forrest Tanaka and ° d ONLN dB§ üØ › (À Ω Paul Snively
° d ONLN dN£ ›Ø Ê )> ° d ONLN dQ£ ÊØ˚ ) ;Taking advantage of NuBus memory for off-screen graphics is ° d ONLN dç∞ üºÍ (ÿ ΩLtricky. Here are some tips on how to do it in a friendly, compatible way.
° d ONLN dŸ±Íºˆ (ÿ95
° d ONLN d›Δ S÷ ` (Ò qQ ° d ONLN dfiΔ c÷ g ) ° d ONLN dflΔ j÷ u )& ° d ONLN d‡Δ x÷ | ) ° d ONLN d·Δ ÷ ä )A
° d ONLN d„… ü’u ) .Answers to your product development questions. ° d ONLN d÷ ü‚ *
Macintosh Q & A
° d ONLN d&◊‚
)b82
° d ONLN d+„ üÔ Û ( ΩApple II Q & A
° d ONLN d<‰ ÛÔ ˇ )T92
° d ONLN d@˘ M Q ($ kI ° d ONLN dA˘ T _ )N ° d ONLN dB˘ b n )D ° d ONLN dC˘ q | )E ° d ONLN dD˘ ä )X
° d ONLN dF˝ ü ´ ) 99
° d ONLN dK ü"x *%The Developer CD Series Disc Volume X ° d ONLN dpx"Î )Ÿ accompanies this issue of ° d ONLN dã# ü/ « (K Ωdevelop. ° d ONLN dì# «/Â )(B Along with the code described in this issue, it contains all back ° d ONLN d◊0 ü< Δ (X Ω
issues of ° d ONLN d·0 Δ< Ì )'develop ° d ONLN dÈ0 Ì<¯ )'8and other software and documentation that will make your ° d ONLN d"= üIm (e Ω-programming life easier and more interesting. o 4o!
Ú *MAt the last company I worked for we surveyed a lot of developers on this, and ° d ONLN d >
ñΩ * @most of them seemed to agree. We decided to divide our technical ° d ONLN d ñ%˚ * Pdocumentation along those exact lines: concepts versus reference; concepts would ° d ONLN d –% ñ1˚ * Malways be available as a printed manual while reference would be on-line only ° d ONLN d
1 ñ= * (or primarily, at least). 0 x -
®
y . ß ö ˇÅ ¶ ã S S ¶ ã y . ß @ c cB cB˛ cB c cÑ˝ cB cB cB cB˝ cÑ c cB˝ c Ѹ cÑ cÑ˛ c Ñ˛B˛ c B˛ cBÑB•B¸ cB c cÑB¸ c
B cB c cÑ c cB cB c cÑ˛ cÑB˛ c B¸ cB cB¸ cB cB˙ c B˛ c B˛ c B¸ c B ú˘ cÑ cÑ˝ cBB¯ c Ñ˙ cÑ cÑ cÑ˛ c˛Ñ c˛Ñ¸ c
Ñ cÑ cÑ cÑB• cÑ c cB˛ c B¸ cBÑ˙ c Ñ cÑ cÑ c cB c c˛Ñ c cB˝ cÑ cѯ c Ñ cÑ cÑ ∞˚ c B˛ cB cB cB˛ cB c cÑB cBÒ cÑ c cBÑ˘ cB cBÑB c cÑ cÑÑ ÁÑ• c˛B c cB cB cBÑ˝ cÑÑ˘ c B˝ c˛Ñ c cB cB˘ cÑ c cB˛ cB c cÑ˝ c B¸ c Bˇ c ∂¸ cB cB˝ c Ñ˚ c B˙ c B˜ cÑ cÑ cÑ cÑ˛ c Ñ˚ cÑ c cÑB c cÑ c cΔ•Δ!! ÁÑÑ c• cÑ˛ cÑ cÑ˝ c B˝ c Ñ˛ c˛ÑBÑ c• cÑ c cB˚ cÑ cÑ˛ c Ñ˛ c Ñ˙ cÑ cÑ˝ c ¥B cB cB cBÑ˝ cB cB cB˛ cB cB cBÙ c B˝ c Ñ˛ c
Ñ c cÑ c•Ñ!B c cB cB˛ cB cÑÑ cÑÑ cÑÑB cÑ cB cB˚ c ÑÛ cÑ cB cÑÑ˛ cÑBÑ˛ c Ѹ c Ñ˘ c B˚ c ˝ cÑ cÑ c cBÑB˝ cÑ cÑ˛ c Ñ c cBÑ cÑ cÑ c cBÑ˛ c Ñ˛ c˛Ñ •Ñ cÑΔÑÑ cB c˛B c¸B c!˛B c˛Ñ •˛Ñ˛ c Ѹ cÑ cÑ˛ cÑ cÑ˛ cÑ cÑ cÑ˛ c˛Ñ cѸ c Ѹ cÑ cÑ cÑ˛ c Ñ˘ c »¸ c Ñ˝ cB cB¸ c B¸ c BÑ c cBÑ c cBÑ˙ cÑ c cÑ•B•• cÑ c!B!B•BBÑÑ c! c!B!˝B!ÑÑ cÑ c cÑѸ c ÑÙ cÑ cÑ cÑ cÑ cÑ c cB cÑÑ c cBÑ˝ cB c cÑ˛ cÑ cÑ˚ c B ¬ cB˚ c ш cÑ cÑ cѸ c˛Ñ cÑ cÑ cÑ cÑ c˝ÑΔѕѸB cBB c c˙B!B cB c!ΔB c c!BBÑÑ˝ cÑ c˛Ñ cÑ˛ c˛Ñ cÑ c cÑÑ cѸ c˛Ñ c c˛B cB˚ c
Ñ cÑ cÑ cÑ cÑ cÑ ª˝ c B˚ cÑB c cÑ˛ cÑ c cBı c Ñ˛ cÑ cÑBÑÑ•ÑΔ c cB cBBÑ cBΔ!B!B!¸B!B cBBÑB c cÑ cB! c cB˛ cÑ cÑ c¸Ñ cÑ cÑ cÑ cÑB˚ cÑ cÑ˚ cBÑÛ c Bˇ c ÿ c cш cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ cÑ cÑ c¸Ñ cÑ cÑÑ••Δ¸B c˛Ñ c! cBB! c¸B cBB cB!B cÑ c•• cBB cÑ cÑ c c¸Ñ•ÑÑ c˛Ñ c˛Ñ cÑ cÑ c˛Ñ c˛Ñ c˝Ñ•ÑÑ c˛Ñ cÑ cÑ cÑ cÑˇ c ± c cB˛ cB cB˘ cÑ cÑ˚ cB c cÑ cÑ cÑ˘ c• ÁΔÑ c˛B! cBB!˛B !B!B!B! c! c cB!˛B !¸B c cB˚ c Ñ˛ cÑ cÑ cÑ cѸ cÑ cÑ cÑ˛ c ѯ c˝Ñˆ c B ”˝ c Ñ cÑ cÑ c cB c cÑ c˛Ñ c˛Ñ c˛Ñ cÑ cÑ c˛Ñ BÑ c cB•ΔÑÑ•˛ÑBBÑ!˝B˛ c˝B!BB c˚B
!BB cBB cBB c c˛Ñ c¸Ñ c˙Ñ c˛Ñ c˛Ñ c˛Ñ cÑ cÑÑ c cѸ c ÑÑ•ÑÑ c cB cB˛ c B˛ cB c cÑB˝ c
B cÑ cÑ cÑ c cÑÑ˛ cÑ c˛Ñ cÑ c• cÑÑΔ c cB• cBÑÑΔ•! cBB!B!˛B!B!B!BB c!B!B!B!BBÑÑ••˛B!Ñ cÑ cÑ cÑ˛ cÑ cÑ cÑ˛ c Ñ˛ cÑ cÑ cÑ c cÑÑ cÑ c cB c cÑ˛ c ÑB cBÑ c cB cB cB º˜ c˛Ñ cÑB˛Ñ c˛Ñ c¯Ñ c˛Ñ c%) ÁBÑÑ%)˛Δ Á•Δ•Ñ˛B c c˝B !˛B !˛ c !˛B !˛B!B!BΔÑBÑ c˛Ñ c˛Ñ c¸Ñ c˝Ñ c cÑ cÑ c˛Ñ c˛Ñ c˛Ñ c˛Ñ cÑ˙ c˛Ñ cÑ ‘ c cB˛ c B cB c cÑ cÑ cÑ˝ cÑÑ c˜Ñ c cÑÑ Á•BÑ!! c Á Á••Δ˛Ñ !¸B!B!˛B cB! cBB!B!B!B!B!˛B ÑÑ!B c cÑ c cÑ cÑ˛ cÑ c˛Ñ˛ c Ñ˛ cÑ cÑ cÑ˛ c Ñ˙ c Ñ˝ c B˚ cÑÑ µ˛ c Bı cÑ cÑ˛ c Ñ˛ c¸Ñ•Ñ• ÁÑΔ%)˛ Á c•• Á˛Ñ cΔÑBB c• c c˝B! cB c˛B c˙B cBB!˛B• cBB cÑ c˙Ñ cÑ c˛Ñ cÑ cÑ cÑ c¯Ñ˛ cÑ cÑ˛ c Ñ˛ c Ñ˚ c ÂB cB cB cB˚ cÑ cÑ cÑ˛ c Ѹ cÑ c••ÑÑ! ÁΔ Á•B• cÑ!ΔB cÑÑB!Ñ! cΔÑ˛ cB cBÑ cÑ!B c˛B!B!˛B !˛B !B! c cB!Ñ cÑÑ•˘Ñ c˝Ñ c cÑ c˛Ñ cÑ cÑ˛ c
Ñ cÑ c cB c cÑ cѸ cÑ cÑ c ¿˜ c˛Ñ cÑ˛ c˛Ñ cÑÑ c cÑ cΔ•ÑΔΔ•Δ! ÁB• c Á• c! cÑ cB˛ c B•Ñ••ΔÑÑ••BB cÙB ! cBB!Ñ!Ñ cBBΔ c˝Ñ•Ñ•˘Ñ cÑÑ•˝Ñ c˙Ñ c˛Ñ c˛Ñ˛ cÑ cÑ cÑˇ c æ˛ cÑ c cB˜ c Ñ˛ c˘Ñ cÑΔÑ%) c Á• cÑ• c c˝B
! c cB!B! c! c%)˛Ñ••ÑÑ cÑ c˛Ñ cÑ c˛Ñ cÑ cÑ c˛Ñ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˚ c B fl
c cÑ cÑ cÑ cÑ c•ÑÑ c˝Ñ •˚Ñ •˛Ñ• Á Á)J ¸BÑB cΔÑ c c•˛B
•! cÑ c••!1åÑÑ˝ cÑÑB••%))J%)%)!Ñ•BB c cÑ ÁB c˛B cB!Δ˛Ñ cÑ c•ÑÑ c˛Ñ c•ÑÑ c¸Ñ cÑÑ•˙Ñ˝ c˛Ñ cÑ cÑ cÑ Í¸ cÑ cˆÑ c˛Ñ cÑ•˛Ñ c˛Δ3Ñ cB cB c!BΔÑ••BÑB c cÑB c c Á• Á5≠ΔΔÑ!B c c Á1åF1=Ô1åJRJRVµRîB%)ΔΔ• c cÑΔ•Ñ˝B!B• ÁÑ•ÑÑ•Ñ cÑ c• cÑ cÑ c˛Ñ cÑ cÑ cÑ cÑÑ•ÑÑ c˛Ñ˛ cÑ c cÑÑ cÑ˛ c ‘¸Ñ c•ÑÑ cÑÑ•˛Ñ•Ñ•Ñ•Ñ••Δ¸•Δ Á˛B Ñ•Ñ c cÑ cBB cB•˛ÑBB c Á)J1åNsVµNsNscRîJR=Ô^˜cZ÷^˜ccg9^˜g9NsJR1å˛ΔÑÑΔ• c c˝B c cΔˆÑ c• cÑ cÑ cÑ c¸Ñ cÑ cˆÑ cÑ cÑ cÑ cÑ ¯ cÑ cÑ cÑ cÑ c˛Ñ cÑÑ••˝Ñ˛•ÑÑ c• cΔ!ÑBBÑB c• Á•Ñ cÑ cB˛•Δ cBB! c-k9ŒJRcco{co{^˜ckZ^˜wΩ˛o{
ckZRî^˜B)J Á Á•ΔBB•Ñ˝B!BB•˛Ñ •Ñ•ÑÑBÑ cÑÑ˛•˛Ñ• c˛Ñ cÑ cÑ c cÑÑ c˛Ñ cÑ cÑ cÑ cÑ˛ c ÷Ñ c¸Ñ cÑ c˛Ñ c¸Ñ cÑ••Δ¸Ñ Δ ÁB cB!BÑBÑÑ•!•ΔÑÑ c•• cBB! Á1å9ŒRîZ÷g9o{˛sú{fisúsúwΩsúwΩo{o{g9g9^˜Vµ5≠%)!ΔÑÑBÑ c c! c˝B c˛Ñ• cÑ c c˙Ñ˝•ÑÑ c¸Ñ c˙Ñ cÑ c¸Ñ cÑ cÑ Ì¸ cÑ cÑ c¸Ñ cÑ cÑ c˛Ñ, cΔ cÑ c c!Δ!B cÑΔ%)!••ÑB!!B!B• ÁÑB!!Ñ5≠!Bg9Z÷o{g9o{súo{o{wΩ{fi{fi˛wΩ o{˛g9Rî5≠-k-k ÁÑ cB! c cB!B!˛B c•ÑÑ cÑ cÑÑ•˚Ñ cÑ c˛•˝Ñ cÑ cÑ cÑ cѸ cÑ cÑ cÑ cÑB ÷¸Ñ c˝Ñ• c˜Ñ˛•(Ñ c• Á!BÑ• c•%)Ñ!•)J• cB cÑΔÑ c cBB!1å-k1åZ÷g9co{o{wΩo{súsú{fiwΩ˛{fisúo{kZkZccB9Œ)J!• c cBB˛ c˛B Ñ˛B••¸Ñ cÑÑ˛•˙Ñ˛•
ÑÑ cÑ cÑÑ•ÑÑ c˛Ñ cÑ c˛Ñ cÑ ’ c˚Ñ •ÙÑ•ÑÑ cÑÑ cÑB•Ñ c!F1-k!••ΔÑ˛B!BB c cB %)%)-kRîccg9kZsúkZsúsúwΩo{˛wΩ˛súo{kZkZZ÷JR5≠)J!!Ñ cBB!BB c!BB c! c c•˝Ñ c cÑ•¯Ñ c cÑ••Ñ• cÑ c¸Ñ˛ c Ñ˛ cÑ cÑ c ”˛Ñ˝•˛Ñ˛•Ñ•¸Ñ •˝Ñ c˛Ñ$! c cÑ Rî%)ΔÑ%))J•BÑ!BBÑ cÑ!)J5≠JRZ÷g9^˜^˜g9súsúkZsúsúwΩwΩ{fi˝wΩ o{g9g9cg9Vµ9Œ5≠)J! cB c˛B c cB˝ cÑ c c•Ñ˛•Ñ•˛Ñ •˛Ñ•Ñ•Ñ•ÛÑ cÑÑ c c˛Ñ cÑ fi•Ñ cÑÑ•ÑΔ˘•ÑÑ c˝Ñ c c•ÑÑ%)! c!Ñ•9Œ-k• Á c•%)JR)J!!B!B!!1åNsRîZ÷Z÷˛cg9g9o{súsú¸wΩsúsúkZkZg9cZ÷VµJR=Ô%) Á• cBB c cB c˛B c c•!BB¸Ñ c˛Ñ c˙Ñ cÑ c¸Ñ c cÑÑ˛ c Ñ˛ cÑ cÑ˛ c Εѕ˛ÑΔÑ•ÑΔÑ˘• Δ˛ÑF•• c•%) Á Á•• ÁF11å cΔB c9Œ9Œ%) Á•ÑBB Á%)=ÔNsVµRîZ÷cg9kZo{kZsúo{wΩo{súwΩwΩsúsúo{o{kZg9c^˜VµNs5≠1å Á• cÑ cÑ c c• cBÑB cBÑ˛ c˛Ñ cÑ cÑ c˝Ñ• c•˛Ñ •˘Ñ c˛Ñ c cÑÑ cÑ c˛Ñ ¸˝• Ñ˛•Ñ••ΔÑ••Δ˛•,Ñ ÁÑ c cÑ cB c)J-kΔ)J Á)J-k-k!BÑ!ΔÑÑ! ! cÑ Á-kBRîRîZ÷co{kZo{o{súo{wΩsúwΩ˛sú wΩo{o{kZg9^˜^˜Z÷RîJRF11åΔ• cBÑB c cΔBBÑÑ c cÑ c c˛Ñ•Ñ c cB˚ cÑ c˛Ñ cÑ cÑ cÑ˛ cÑ cÑ cÑ cÑ c˛Ñ cÑ c ÚÑ•Δ•Δ•Δ•˛Δ•Δ•Δ¸•# ÁÑ c cΔ•ÑÑ! ÁΔΔ)JÑ%)5≠ c•!)J-k! cΔ Á%) cÑ!-kJRZ÷cco{o{˝súwΩsú{fisúwΩsú˛wΩ!o{súo{g9^˜Z÷VµJRB=Ô1åΔ c cBÑ!ÑΔBÑ c!ÑBÑ c cBB cÑ cÑ˛ cÑ cÑ cÑ cÑ c˚Ñ• c˛Ñ c˝Ñ •˛Ñ •˝Ñ È•ÑÑ˝•Δ•ΔѸ•(ÑÑB c• c!B Á ÁB Á c c!%) ÁÑ Á ÁΔ%)%) Á ÁÑ1å•9Œ%) c•ΔBB^˜Z÷o{kZsúsú¸wΩ o{˝sú o{˛sú o{ckZcZ÷NsJR=Ô5≠!•B c cB c• cÑ cÑÑ• cB•ÑBB c cB¸ cB cBÑ cÑ c¸Ñ cÑ˛ cÑ c˛Ñ cÑ˚ c B•Ñ•˛ÑΔ•ÑÑΔÑ˛•+Ñ c cÑ!Δ c• cΔ cΔ•-kJR-k%)-k!•! Á! c c!Δ•9Œ9ŒΔ c•!F1Vµ=ÔF1Ns^˜kZsú{fiwΩ˛sú&wΩsúo{o{súwΩwΩsúwΩkZo{kZo{^˜^˜RîB9Œ-kÑ cB c!Ñ cÑÑ cB• c•Ñ c c•B c˛B c cÑ cÑ c cB c cÑ c˝Ñ •¸Ñ c c˛Ñ c˛Ñ cÑ cÑ Ô••ÑΔ•Ñ cÑ•˚Ñ c!˛B•Δ˛Ñ!%)Δ•)J5≠1å Á%)5≠5≠!)J%) cΔ c c•!! c c•)J Á!=ÔB-k••1å1åNs˛sú,o{súo{kZkZo{o{kZo{súg9o{o{kZ^˜^˜NsF11åÑ c cB cÑBÑ c cB!Ñ cB•ÑÑB cB!B!BB¸ c B˝ cÑ cÑ c˙Ñ cѸ cÑ cÑÑ ı••ΔΔ•Ñ•˛Ñ••Ñ˙B •Ñ ÁÑ ÁΔ%)-kVµ-k)J-k-k˝1å%)NsNsB5≠-k••BÑ Á!1åRîZ÷Z÷F1Ns!•Ñ%)-kZ÷o{súkZ˝o{ g9kZsúsúwΩsúsúg9ccJRNs5≠ cÑÑ c c•Ñ c cBÑÑ!ÑÑ•Ñ˛ cB cBB!˛B cÑ cÑ cÑ cÑ c˛Ñ cÑ c c˝Ñ cÑÑ cÑ˝ c Ñ Ù Ñ˘•Ñ c c˘B4!ΔΔ Á!-k!9Œ•-kΔÑ Á-k)JRî5≠!B9Œ%)Δ cÑÑ cΔ1å=ÔVµZ÷co{o{kZo{g9F1)J!1å^˜ckZo{o{kZg9g9ckZJR5≠˛)J5≠-k!9Œ=Ô˝ cÑB cBBÑB! cB c• c cBB c!B!B!B!˛B cÑB c cÑ cÑ cÑ cÑ cÑ cÑ c cBÑ cÑ cÑ˛ c Ó •˛Ñ•Ñ•Ñ•ÑÑ c˚BN cBÑB!!%)Δ Á%))JÑBΔÑ•5≠5≠F19Œ=Ô1å%))J!•ÑÑ)JJRJR=ÔVµ=Ô%)-k%)%) Á%)NsNs9ŒNso{kZo{kZkZg9RîRî1å••B c cÑ=Ô1å%)-k c cBÑBBÑ c cBÑÑ c cBΔ˛ c јB! cBÑ˛B c c¸Ñ cÑ cÑ cÑ c˝Ñ •ˇÑ ıÑÑ••˛Ñ
• cÑ cÑ cB!B!!˛B<! Á•• c c•Ñ!! c••B!1å!)J Á c! cÑ Á5≠Z÷B=Ô•!••Δ-kΔ-kΔ=ÔF1RîkZkZo{o{kZcVµ5≠1åF1=Ô^˜g9o{Rî=Ô9Œ%) cB˛ c!BÑBÑBÑB c! cB• c c˘B!B!B!˚B c c˛Ñ c˛Ñ cÑÑ•˝Ñ cÑ c Èe••ΔÑ••ÑÑ•Ñ cÑÑ cB!BB cBÑÑB)J Á•Ñ!Δ!Δ•Δ-k ÁBBÑ Á!Δ!BB%)-kF1Rî5≠-k%)%)=Ô%)!ΔZ÷^˜Ñ=ÔJRF1csúwΩsúg9c5≠1åB)J%)1åVµckZo{kZ^˜-kBÑ c cBB cÑBÑB c c•B c c•B c c˙B !˘B˝ cÑÑ•˚Ñ c˙ÑÑ••¸Ñ˛ cBBÑÑ c!B!˛ c!!9Œ!Ñ˛ ÁG%)!!Ñ c! Á! Á5≠%)Δ c-k9ŒRîNsRîNs=ÔVµ^˜RîNs^˜JRB5≠1åVµF1VµwΩwΩkZg9F1!Ns1å1å%)Ñ !1å1åJRBB•BB c cB c•!!Ñ cÑ cBBÑBÑ! c˝B !˛B!B!B!B!B!BB c cÑ cÑ cÑÑ c c˛Ñ cÑ cÑ c Ë• cÑÑ•Ñ•Ñ•˛Ñ˛ cÑÑ c˝B˛ c<%)9Œ1å-k c%)ΔÑB c!•)J-k1å)J%) c1åB^˜co{kZcJRVµ^˜Z÷^˜F11åB^˜cBVµkZkZcVµ9ŒNs5≠ c9ŒRî)J%) ÁB)J%)5≠5≠ ÁÑB c•˛Ñ•BB c•˛ cB c cÑB c¸B c˚B !˛B !˝B cBÑ c cÑÑ c˙Ñ ˙ cÑÑ•¯Ñ cBB!ÑB˛ cIBBÑ cBÑ• Á•Δ!•B cB)J!%)!-k c1åNsg9kZg9o{g9g9cVµRîJRF1RîVµJR9ŒZ÷BNsVµRî9ŒF1=ÔcVµNsVµ=Ô-k-k9Œ •)J9Œ%)B c Δ cÑB cÑBBÑΔÑ˛B cB cB cBB!B!˛B !˛B
!B!B!B!B!BB˝ c Ñ˛ cÑ cˇÑ ŒÑÑ•Ñ•Ñ•¸Ñ •˛Ñ cBÑÑ c•B c cΔ• cÑÑ•˝ c
BB•=Ô)J%)5≠ c1åNsckZkZ˛o{c^˜g9˛sú$cNscF15≠JRRîB5≠JR1åVµB1åJRg9cVµNsB5≠ ÁF11å c cB!1åÑÑ!BÑѕѸ cËB !˝B c cÑ cÑ cÑ cÑ ˙˙Ñ •˚Ñ c cΔÑ cÑB•Ñ•ÑΔ˛Ñ?B cÑB cBB c!)J9Œ Á-k B9ŒF1^˜cg9kZo{o{kZkZcc^˜Z÷Z÷VµJR-k-k9ŒF1F1)JBNsNsc^˜BRî^˜^˜NsVµJRNsNs9ŒΔBB!ΔΔÑÑ!Ñ!˛ÑB cB cB c!˛B!B!B!B!B!B!B!B!B!B!B!B!˛B cÑ c˛Ñ c ÷ •˛Ñ•Ñ•˛Ñ•ÑÑ•• cΔÑ cÑ cÑÑΔB cÑ•˛Ñ B˛ c;! cB1å)J• Á!B9ŒF1VµZ÷g9co{g9o{o{g9^˜cZ÷NsB1å9Œ9Œ=ÔJRNs-k5≠VµRîg9súo{cZ÷VµkZcc^˜Z÷5≠Δ c cB!ΔÑ cΔ c Á•Ñ¸BÑ c¯B !ÓB!BB c c˛Ñ ı Ñ˛•Ñ•˙Ñ%•ÑÑ Á Á••ÑBÑ c%)!%)!•ΔÑÑ!B cBB cΔΔ%)• B1åBNsVµ^˜cg9˛kZcg9Z÷Z÷RîJRB9ŒJR˛Rî1å-kF1RîVµc˛o{wΩsú˛g9Z÷=Ô• c˝B cÑBÑBB!B!B!B c!B c!˛B !˛B!B!B!˛B!B!B!˛B !˛B!B!BB c c …Δ•Δ••Ñ•˛Ñ •˝Ñ ÁÑΔ Á! c˛Ñ!Δ ÁÑ•Ñ Á!Ñ•B cÑB Á c-k!B c9Œ=ÔNsZ÷cg9kZo{˛súkZkZo{g9^˜JR1åRîZ÷NsB1å=Ô9ŒNsZ÷Z÷g9˛súwΩsúkZcVµ9Œ!¸B
cÑÑBB! cBB!BBÑÑ˛B !‚B!Ñ ÒÑ•˛Ñ•Ñ•˚Ñ ÁÑ••˝Ñ3B c Á%)•ÑÑ•B)J c•• c!•Ñ5≠•B! c5≠BJRNsZ÷kZg9súsúwΩsúsúkZg9B=Ô1å9ŒVµZ÷Z÷9Œ-kBRîVµVµ^˜^˜g9˝o{^˜cVµ1åÑ˝B c!B!˛B!B!˝B c cB!B!B!B!B!B!B!˛B!B!B!B!˛B !¸B!B! ÃΔ•Ñ••Ñ•˝Ñ2 cÑΔ c c ÁΔΔ• Á!•!!•Ñ!B c• %)Δ Á c••1å• cBB c=ÔB9ŒJRVµckZkZwΩkZo{^˜JR5≠9Œ=Ô9ŒRî˛Vµ=Ô5≠1å=Ô^˜kZg9súo{kZkZg9g9Z÷RîVµ-k•!B c cB c˚B !˛B c••Ñ! cÎB !ˆB ˙˛Ñ •˝Ñ cÑ c˛Ñ B••ÑÑ c•Δ! Á˛B cB c!B cΔ1å-k˛!* c!B!Ñ5≠F15≠F1JRZ÷g9kZg9g9VµB9Œ5≠RîBB^˜Rî^˜^˜Rî9Œ-k-k5≠ckZg9o{kZkZc^˜VµNsF1%)˛B cB c˛B c˝B cB c cBÑ c• c˛B !˛B!B!˛B!B!B!B!B!B!B!B!˛B!BB “••ÑÑ c c˛•Ñ•Ñ cB cΔΔ˛• cÑ•ÑÑ˛B c! c cΔ!•Δ%)%)!!˝B)=ÔNs9Œ=ÔJR^˜Z÷^˜^˜Ns=ÔRîg9Ns=ÔJRNsVµsú{fiwΩRîF15≠F1-kNsg9o{kZo{o{g9^˜VµF1=Ô Á!B c c˝B cBB c c• cB cÑÑ!Ñ!BB cÎB !¯B ˝•Δ˛Ñ˝Δ˛Ñ cÑBB ÁB cBÑ cB cΔÑ c˛B4 cÑ)J!%))JB c!B!B! =ÔVµ=ÔBBNsF1Z÷NsBZ÷c^˜VµRî-k5≠Nso{kZkZZ÷F19Œ=ÔJR=ÔZ÷ckZco{^˜VµJRB1å• ˛B!ÑB cBB!! c cΔ••Ñ cÑ c˙B !B!B!B!B!B!B!˛B !B!B!B!B!B!B! Ñ˛•! Á ÁΔ• Á••ÑÑ cB!ΔΔÑÑ cBBΔ cÑΔÑ c•Δ Á%))JΔ BÑ˚B79ŒNsZ÷VµRîJRNsRî9ŒZ÷Z÷VµRîRîZ÷^˜F15≠RîVµZ÷JR1å-kF1VµJR9Œcg9g9^˜^˜VµNs5≠5≠ B c cBΔBÑBÑ c Á! cÑÑ Á%)•˛Ñ c cflB ˝•
Δ Á• Á••ΔÑ c c!˛B ÑΔ•ΔΔ•ΔB cÑ•Δ ! cB!•ÑÑ!B! 1åZ÷Rî˛Z÷c=Ôg9^˜VµVµ˝Rî^˜Ns=ÔVµJR1åBJRF1NscJRRîg9Z÷cNsJR1å1å Á ˛B
ÁÑÑ•ÑÑ c•• cΔ˛Ñ!Ñ c cÑB cBB!B!B!B!B!B!B!B!¸B
!B!B!B!B!B! ËΔ•Δ Á ÁΔ Á•˛Δ•B cB c cBΔΔÑ cÑBÑBÑ c cÑÑ!B! c cB˝ÑB cB-kJR^˜^˜c^˜kZZ÷Z÷NsRî^˜Z÷Vµ˛Z÷^˜^˜NsRî˛Ns$JRJRNsZ÷RîVµZ÷RîVµ9Œ%)BÑ! cBÑΔB•B%)ÑÑ cBB cÑ••BΔ•B• c˘B!B!˛B !¸B !¸B !˙B •ΔΔ ÁΔ Á ÁΔΔ Á•Ñ!•B!B! c˛B! c!˛B!BÑÑ˛B ÑB c c• ÁÑB cÑF1Z÷g9cg9kZcg95≠ -k%)F1JRVµVµc^˜cZ÷˛JR(9ŒF1Ns^˜RîZ÷RîJR9Œ-k=Ô=Ô B!B c! cBÑ!Ñ cB c!B•Ñ Á c!•Ñ c cB cB!˛B
!B!B!B!B!B!˛B !B!B!B!B!B!B! ‰ ÁΔ ÁΔ ÁΔ ÁΔ ÁÑÑ• cB! c cÑB c cÑΔ!˛ cBB!ÑÑBB c! cB c c ÁB cB!9ŒVµ˛g99o{kZsú^˜ÑBsú9Œ1å-k=Ô=ÔRîNsJRF1Z÷NsJRNsNsRîVµRîVµNs5≠=ÔJR!!BBÑBB c!•ΔÑÑB cBB c c•! cB c! cBB c¯B !¯B !ˆB ˝• Á¸Δ •˛Ñ%)BB c c Á• Á ÁÑ c cÑB cBB!B c•!B c˝B c˝B %)JR˛ckZkZo{cJR RsúJR^˜5≠5≠)J˛ Á#1åF1BZ÷JR^˜VµRîBRî=ÔB!BB c!BB cB•Ñ c cB!BB c c!Δ•B c˝B !˛B!B!B!B!B!B!B!B!B!B!B!B!B!B! Õ •˛Δ ÁΔ˛•ÑÑ ÁΔ c•Ñ cBB c cB cB c˛BÑ!•B˛ c˛B c c¸B'!JR^˜c^˜súckZkZ^˜-k Z÷{fiˇ{fiˇwΩˇsúˇˇ^˜ c JRVµZ÷cZ÷JRNsNs%)!B! cBB˝ cΔBB cÑ!B c cÑBB•ÑB c! c!¯B !ÏBΔΔ•Δ•ΔΔ˛Ñ c ÁBB•˛Ñ˛B cBB!B!• cBÑÑB cBB!¸B&!BB 1åVµcZ÷kZcg9cVµB1å!B{fiˇˇsúo{ˇwΩ{fi Á!VµVµ^˜o{^˜RîNsRî5≠ c!•˝B-ÑB c!Δ c cB cÑ cB! c cB cÑÑ cB!B!B!B!B!B!B!B!B!B!B!B!B!˛B !˛B ! fiΔΔ Á Á!Δ ÁΔ•ÑÑΔBB%) Á c c˛B<!B!BBÑ c! Á cBΔÑ c cBB cB cBB!BBΔJRc^˜^˜kZg9^˜^˜VµF19Œ=ÔÑ!RîNs^˜-k!B!JRRîg9kZg9RîVµVµF1! cΔ ÁB˛ c Ñ˛BÑ• cBB c cÑB cB c!•!Ñ˝B c c¯B cÔB¸Δ! ÁΔ•˛Ñ
!Ñ! Á c c!ÑÑ c c˛BJ c!Ñ c!ÑB•B c!B cBB c!B! c•9ŒVµ^˜Z÷g9cc^˜o{^˜=ÔBRîg9JRB5≠!1å9Œ=ÔB^˜Z÷g9NsRîNsJR! B!!BÑ c c• cB!BÑÑ cBB cB c cÑ!˝B! c cB!B! c!B!B!B!B!B!B!B!B!B!B!B!B!B! ·• Á ÁΔ˛ Á˛•Ñ cB•Δ• c c•B!B cÑB cBÑ c! cB•B˛ cB c cÑ cBB!Δ)JÑF1Vµ^˜g9^˜cc^˜o{cRî˛=Ô-JR1å)J9ŒJRNsRîVµZ÷NsRîVµF1)J!! c c•! c c•BÑB c! cÑ c c••Ñ c c!B!BB c cÑ!˛ cB c˝B !ÏB Û•Ñ cΔ Á•Δ•Ñ•ÑÑB•ÑB cÑ!Ñ! c!˝B c! cB cB cÑÑ c cB˛Ñ$•!!)J)J%))JZ÷Ns^˜g9kZ^˜cckZcg9VµNsJRJRVµ^˜RîNsRîZ÷NsJRJR=Ô)J !B!˝B
cÑBB c! c!BB c cÑ c˛B !˙B !¯B!B!B!B!B!B!B!B!B!B!B! ‹Δ••ÑÑ ÁΔ˛•Ñ•Ñ˛B c cBB cBÑ!B!Ñ cÑBBÑ cB˝ cCÑB•Ñ•B c)J9Œ)J)J5≠NsZ÷o{g9g9ccg9g9c^˜^˜cc^˜Z÷NsF1Z÷VµF1B=Ô%) !B•Ñ cÑ!BB c cBB cB c cB cB! cBB!BBÑBB c˙B cÙB !ˆB ˇ Á••ΔÑ c c•ÑÑ c cÑ˛B@!B!B c c!B! cÑ• c cÑ cB cB cBB c Á c cÑ cB-kF11å=Ô!9ŒJRckZcg9cg9cg9c^˜ccVµNsRîVµZ÷F1=Ô9Œ ÁB!B !1åÑ!˛B !˛B !˛BÑÑ˚B !¸B!B!B!B! c!B!B!B!B!B!B!B!B!B!˛B!BB — Á Á˛Δ••Ñ c˛ÑB cÑ˛B cB cB cB c c•ÑÑBѸ c
! cBB! c!B!Ñ!˛B:!BB cB!•B• Á %)=ÔRîZ÷RîJRJR1å!Vµ^˜ckZkZo{Z÷kZccRîZ÷RîVµJR)JÑΔ%)Ñ!B!Δ^˜5≠•BBΔ!Δ cÑ!ÑÑB!˘B c˛B ѸB c!ÎB cB cB c Ó˚Δ
Ñ••B!• cÑBB!˛B!! cB! c˛B cBB!BB!B••B•)J c ÁNsRîNscBF1JR5≠%)RîVµcg9¸Z÷˛Rî%JR)JB•)J!!B!B )J Á!!BÑB!ÑÑB c c!B!B!B!B!B c c! c˘B !˛B!B!B!B!B!B!B!B!BB cB˝ c “ Á ÁΔ•Δ••ÑÑBÑ Á cB c˚B cBB c c˙B'!BB• Á• c%)ΔΔBÑNsVµ^˜RîVµBJRF1=Ô)J5≠F1F1Z÷NsVµRîRîNsNsJR!ÑÑ%))JΔ!˝B 1å•Ñ!Ñ c!ÑÑ!B c cBB!˛B ! cÑ c!ÑB c!ÑÏB cB˝ cÑ c˛Ñ Á
•Δ•Δ••ÑÑ c!•Δ c!˝B!BB c˝B;!B cÑ cB!B! c•!ÑΔ•!%)• JRVµ^˜^˜Vµ^˜=ÔF1F1B=Ô-k-k)J1å5≠9Œ5≠1å)J Á ÁÑ%)1å!Ñ!B!B!!•B cB••!!˚B!B!BB c˝B!B c˛B!B!¸B!B!˛B !˝B cB˝ c˚Ñ ƒ#Δ•Δ•Ñ•Ñ cBBÑ cÑB cB cBB!ÑB c cÑBB c cΔB!B!BB˛Ñ •Δ1å-k)J!1åRî^˜^˜Z÷^˜^˜9ŒBBF1RîVµJR=Ô9Œ-k-k1å5≠!•!1å)J!!˛B c c˛B•BBΔB!ÑB c!ÔB˛ cB c c˘Ñ • Î •Δ••Ñ•Ñ•! cÑјB, c•• cÑ ÁBÑÑB!B!B cBÑÑ)J5≠=Ô5≠!-kNsZ÷Z÷^˜Z÷Vµ^˜B9ŒF1BJRBJRNsF1=Ô1å%)Δ Á˛-kÑ!BB!BB c!Ñ c! cÑ! cÑB!BBÑ!˛B!B!˛B!B! c!B!˛B! c˝B !¸B c c¸Ñ •˝Ñ cÑÑ ÷ Á•ΔΔ˛Ñ• c!ÑјB cB˛Ñ•Ñ! c!˝B!ÑBÑB9ŒBB9Œ %)NsNsVµ^˜Z÷^˜VµcVµ=Ô=ÔB=Ô=Ô9Œ=Ô9Œ-k Á!)J1å-k!˚B c˝B
! cÑBB cBB!Δ•˚B˛ c !˝B cB c!˛BÑ c˙B c cÑÑ•Ñ•Ñ•Ñ•Ñ˛•ÑÑ €Δ ÁΔΔ•˝ÑB!Ñ cB!B!˛B! c!B!Ñ!˛B!B!B!B˛ c
•Ñ!B!B)JÑ9Œ1å!˛B ! ¸9ŒF1 c9Œ-kΔ)J5≠!•! cB%) cc Á!9Œ˛! Á%) ÁΔ!)J!•!!B! c•B!B!˛B !¸BΔ•!B c˘BH!•%)1å5≠-kNs5≠-kF1NsB9ŒBJRBB)J=ÔF1g9o{^˜cF1cVµVµZ÷g9kZkZc)JJRVµRîNswΩckZg9cwΩRîg9o{^˜o{g9wΩo{{fisúwΩsúwΩwΩΔ!BB!ΔÑ!BB c!! Ñ˝B 8-k5≠ F15≠=Ô!F1ΔÑ •BÑ• cΔ%) B •Δ! Á Á!!%)!!B!B!B!B!B!B!B!B!B!!BBÑB!B!˛B! Δ1å%)5≠!Vµ5≠5≠=ÔRîF15≠BF1=Ô9ŒB=Ô9Œ^˜g9^˜˛Z÷^˜RîVµZ÷VµkZ^˜g9Z÷˛Rî g9^˜cg9g9^˜csúkZwΩckZkZsú{fisúwΩ{fi{fiwΩ{fi{fi Á BB!ÑB!Ñ!¸B!B! ˇ%=Ô1å -k9Œ%)1åJR! ÁB ÁΔ!•Ñ• B!BÑ!! Á! ÁΔ-kÑ!!B! cBB!˛B!BBÑ!˛B!BÑBB c¸B/ ΔB-k)J)JZ÷B1åBRîNs9Œ=ÔF1=ÔB=ÔF1=ÔRîg9^˜Z÷cRîVµVµcZ÷^˜NsRîZ÷VµF1RîVµg9Z÷ccF1Z÷RîNs^˜c˝o{{fiwΩ˝{fi wΩsúˇwΩΔ!B! cBBÑ˝B c˛Ñ c
1å5≠ !F1%)5≠F15≠)J ÁΔ Á!-k B •1åBΔ ÁΔ ÁÑB• ˛! B!B!BB !B!˛B!B!B c cBB!˛B8! •F15≠%)9ŒRî=Ô5≠NsRîRî9Œ1åBB9ŒF1BF1BVµRîZ÷g9Ns^˜g9g9ccg9kZRîNsF1=ÔNs^˜JRJRB5≠=Ô5≠F1=ÔF1Z÷VµZ÷kZsúo{ˇo{˝súwΩsú{fi^˜Δ•ÑBB c c!B!B!B•%)9Œ F1F1 !-k9Œ-k%)Z÷BBB Á•ΔB c!%))J-k c• ÁÑ!! B)JÑΔ¸B!!!B!B!¸B! c!˛ c˛BA ÁB9Œ%)=ÔZ÷BJR^˜NsJR=Ô1åBB=ÔF1JRJRBF1RîNsVµZ÷o{kZo{kZ^˜^˜Z÷cF1RîF1RîF11å1åJR%)B5≠-kF1JRZ÷F1g9cg9kZg9o{súsúwΩsú{fiwΩ{fio{ˇ%)˝B•!˛B!B!! NF15≠ !-k1å=Ô%)1åJR c! cΔΔÑBΔ)J!!• c!!B BΔ•! Á c!!B!BB!!B!B!B!B!B!B c c!B! )J=Ô9Œ)JBZ÷9ŒF1RîJRF1=Ô-k=Ô1åF1JRJR=ÔBB˛JRcg9súo{súg9Z÷cRîNs=ÔF1NsRî5≠˛VµZ÷VµNsNsF1BNsVµ^˜o{kZsúkZwΩwΩ˛ˇ
o{{fisúsúo{o{! cB! Á! cÑ˛ cÑÑ••)J)J Ñ-k-k%) Á%)1åB! c•ΔÑ!! Á˛! c˛!•!!B!%)Δ•˙B!B!¸BQ!BBÑBB! 1å=Ô9Œ1å=ÔRîBRîJRBF1B9ŒBJRVµNsJRJRNsNsF1F1Vµco{o{súo{súc^˜VµJRRîZ÷Nso{wΩ^˜súo{kZZ÷g9cNsF1BRî^˜Ns^˜kZsú{fisúg9g9^˜!-kˇ{fio{wΩg9 B c!%)!Ñ˛• ÁΔΔ•• 9Œ1å! c-k5≠1å Á)J! B ÑΔ Á !Ñ!!%)!BÑ!˛ Á)!^˜1å•!!B!B!B!B!B!B!B cBBÑBB!B%)9Œ9Œ1åBJRF1F1=Ô5≠Ns=ÔF1RîVµ˛JR F1RîNs=ÔBZ÷kZkZsúwΩ˛kZVµRîJRkZo{kZwΩcZ÷g9kZkZZ÷kZJRVµc1å1å%)-k˛! %)˛ΔB =Ôˇ{fiwΩ{fikZkZ cB!!%)!B•˝ÑΔ••!=Ô1å! 5≠5≠F1!5≠%)Ñ %)!ÑÑB!B Á!!B! Á Á!! Á• Á%)•!ˆB!BÑ c c•BB!!)JBF19ŒF1RîF1JRBRîZ÷Rî˛Vµ'NsF1F1NsRîF1B1åJRo{súsúwΩsúkZg9Z÷Z÷kZsúg9o{g9g9kZkZ^˜kZg9cg9c^˜Z÷=Ô%)• cÑΔ˛ Á!• =Ô{fi{fiˇˇwΩˇo{=Ô B!)J!Ñ c•Ñ••Δ•• 9Œ5≠ -k-k%)%)=Ô%)BB!• c•!BB Á B!BÑΔÑΔB c˛•a!BB!B!B!B!B%) ÑÑ c•!B! )JBJRBNsRîNsRîRîc^˜^˜Z÷RîRîJRBJRRîNsNsB)J1åg9o{súwΩsúsú^˜Rîg9o{o{g9ckZg9^˜o{kZkZo{kZo{^˜o{g9Rî9Œ9Œ-k Á!Δ• ÁΔ• -ksúsú{fiˇ{fi{fiwΩˇo{1å!B%)B!¸Ñ˛ c!1å9Œ 5≠B1å%)Rî%)Ñ!BÑBÑB! c!B cΔ cΔ Á9Œ)J ΔΔ•!˛B c•!B!B!•!ÑBÑB cB -kBF1BNsJRRîNsRîc^˜˛Z÷ VµNs=ÔNsRîNsNsB-k ÁZ÷súsúˇo{súcZ÷o{kZg9kZRîg9^˜o{c^˜kZcg9kZ˛o{súg9Rî=Ô)JÑ%)˛ÑΔ 5≠ckZˇ{fiwΩˇ{fi{fiwΩˇˇJR!!BB˘ c 9ŒF1 ! Á1å)J=Ô9ŒNsB!!%) c•BB•B c-k%)ÑΔ•9Œ˛!&•Δ•B!B!ÑB !B!B!BB c cB! )JBF1=ÔBJRZ÷RîRîZ÷Vµ^˜^˜Z÷Z÷JRF1˛NsF15≠)J c)JcwΩˇo{súg9VµckZg9Z÷NsVµRîRîcg9˛c o{súo{kZkZo{g9g9Z÷)J˛ΔÑÑ =Ô^˜Nso{˛ˇ {fiˇˇwΩsú{fi^˜! Á c˛B cB cB cB ¸F19ŒB 5≠-k)J5≠%)1åÑ!B!)J˛B Á c c!•1å! Á!-k!• ÁRî-k!˛B!%) ˙B
c cB !F1JR=ÔBRîVµRîZ÷^˜˛c^˜^˜RîJR˛Vµ1Ns5≠ΔB•Z÷o{súsúo{g9^˜o{kZg9^˜VµF1B5≠1å1åNskZsúkZkZo{kZkZg9kZsúwΩg9JR%))J•• 9Œ5≠F1^˜{fi{fiˇ{fi{fi˛ˇ wΩ{fiwΩ• ÁÑBB cB¸ c ˇ5≠9Œ1å 9Œ)J=ÔÑ• ÁΔ! )J%)Ñ!BB cBÑVµ%)%)Ñ Á˛• c1å!˛B!B B!˙B0! ÑNsF1JRBRîRîVµcg9^˜^˜cg9Z÷RîNsVµRîNs5≠! cBΔ%)VµwΩwΩo{kZZ÷kZsúkZcF19Œ-k)J!! c c)Jcg9˛o{kZsúkZo{g9o{^˜5≠BÑ!-k=Ô•9ŒwΩ{fi{fiˇ˛{fi˛ˇ
{fi{fi%)••! cB c cÑ˛ c Ó!-kNs• %)1åB!•!1å Ñ!%)!B Δ Á c ÁÑ Á c•BΔÑB ÁÑ!˛B !ˆB NsJRRîJRRîNsRîg9g9ckZg9kZZ÷RîNsRî1å%) Á c˛• Á=Ôsú{fi{fisúg9kZsúo{o{Vµ9Œ%)Δ cB!BBÑ5≠o{g9kZo{˛súkZsúo{^˜%)%) cÑ!B)J5≠RîˇwΩ{fiwΩ{fi{fi˛ˇ{fiˇ1å•Δ¯BrB=Ô !!1å-k-kBΔ1å )J!! Á cΔ c•BJR cÑ! c cÑ!9ŒÑ!!B!B!B!BB!B cBB 5≠RîVµVµRîF1Rîc^˜ccg9g9VµJRB1å%)5≠%) c c)JΔΔ)JF1súsúo{o{^˜súsúkZZ÷1åΔ•!Δ1å=Ô5≠ Á c 5≠kZ^˜g9súkZo{o{^˜kZo{NsΔ!1å! c!%)¸wΩ¸{fiˇˇ1åÑ!! c˛B cB cBåJR !B1å!B cΔ1å !%) Á%)%)!!Δ c%) JRÑ!ΔB˛ c!!˝B !¸BH c cB c )JJRRîRîNsNsRî^˜^˜Z÷cg9g9VµF1=Ô=Ô Á1åΔ !Ñ!! Á-kcwΩ{fiwΩcg9wΩsúg91åΔ• 5≠JRF1=Ô=Ô-k!%) 5≠Z÷VµZ÷g9kZg9o{g9kZRîΔ!)J Δ1åBZ÷˛wΩ{fiˇ{fiˇwΩ˛ˇ ^˜•)J!B cB cB cB c
ÑΔ•! c! !B!! cΔÑ˛!B!!B˛%)˝Δ •ÑÑ•• Á•!5≠ c!BΔ˛1å%) Á c c˝B!B!B!B!B!˛B!B!B!BBÑ! ÁNscVµVµ^˜o{o{súsúwΩwΩ{fikZwΩˇwΩo{˛{fiwΩˇ˛wΩsú{fiˇ{fiˇ)J BJRNs^˜kZsúcVµ9Œ ÁΔÑ!-k)JBÑ•˛Ñ˛Δ˛•Ñ!B!BΔ Á˛•1å 1å)J !B ÁΔBBÑBBÑ cB Á Á˝Ñ=Ôc5≠)J!%)ÑÑB%)%) c!-k-k)J%)%)•B cB!˛B !˛B !˛B !˛B !˛B@!ÑÑ Á!cZ÷cRîco{kZo{súsúwΩwΩo{kZsúo{VµF1RîkZˇcsúRîˇ{fi1å1å-kÑ!! ΔckZVµkZsúkZsúg9VµVµcc1åBÑÑ•Δ ÁΔ•ÑΔ••!˛B c%) ÁΔÑ c!•)JÑ!!ÑΔÑÑ! Á cΔ˛Ñ'BÑÑ5≠ ÁÑÑ!!ΔΔ)JÑ!-k! cÑ)J!%)%)! cB cBB!B!B!B!B!B!B˛!B!˛B Ñ• Á!^˜g9Z÷^˜Z÷g9o{o{^˜kZckZo{o{súZ÷ÑÑB5≠1åΔ!Δ%)B˝ BB! NsVµRîckZcJRF1g9RîNsRîNs c cÑÑ••ÑÑ•• c c¸B • ˝3!Ñ•Ñ ÁΔ=ÔBB!•Δ•B c•B cΔ c c ÁÑ ÁB!1åÑB!F1 Á•Ñ!-k Á c! c%)%)! Á•! c•B cB!˛B !˛B !˛B !¸B !ΔΔ%)•NsRî^˜Z÷kZcg9^˜kZg9kZo{súsúc%) Á •!)JÑΔ c !˙B!ÑZ÷c^˜^˜Vµ^˜kZ^˜^˜VµF1RîBÑÑ˛•Ñ•Ñ• c˛B!! Á!
!B˛Ñ1 Á1å!!B! c• c•BB c!• c ÁΔ c! c c•Ns9ŒΔÑ•• Á-k)J1å ÁÑ Á!!Δ!•Δ cBB!B!B!˛B!B!˛B !˛B%!B••)J ÁF1cRîVµkZcckZg9kZkZo{o{cÑ!-k•!9Œ5≠1å!ΔBB!B!B!B˛! RîcZ÷^˜^˜kZsúkZZ÷BcVµ c cÑ cÑÑ•Ñ c cB!B!!Δ c ¸5%)•ÑÑ cNsÑ! ! c! cΔΔBÑ cΔ!Ñ Á Á!• cΔÑ Á5≠ ÁÑ)J1å%)•Ñ• Á cB!Δ c cÑ!B cBB!B!˛B !˛B !˛B$!B!BÑΔ Á! Á=Ôc^˜Nsg9^˜ckZg9o{kZo{kZF1Ñ )J1å%)1å5≠9Œ1å!ÑBB!˛B!BB JR^˜˛g9kZg9Z÷=Ôc^˜Rî˘Ñ˝B!•Ñ •!
d ° d ONLN d Û ˇ n ( -
CAROLINE ROSE x Bx/
(Ö . )2
+Ç
CAROLINE ROSE )Dhas been writing computer (ô ¥documentation ever since )V )“peripheral storage” meant (£ ¥.paper tape. After a seven-year digression into *
5programming, she returned to writing and joined Apple *
0to document the inner workings of a new computer *
3named Macintosh. In what proved to be another (five )Ø- (À ¥/year) digression, she left Apple to launch NeXT *
/Computer’s documentation effort—a real learning *
4experience. She’s thrilled to be back at Apple among (èv8old friends and new. Caroline loves to read, swim, hike, *
9travel, dance, sing, and spend time with her best friend, *
2Cleo (see photo). This summer she got her feet wet *
4(literally) on a backpacking trip in Utah, through a *
0tributary of the Escalante River and some pretty *
1spectacular canyons. Her new wilderness goals are *
-hiking up Half Dome and rafting the Colorado. )ô•
4◊q·3
(Ú Dd )e )v )e )l )o )p )
) Autumn 1991 ˇ Æ ◊# ˇ ˇˇˇˇ # ◊
d , Palatino
. ° d ONLN d v Çí +6ûUThis all ties in with the fact that Apple Associates and Partners no longer receive a ° d ONLN d V Ç é ^ * printed copy of ° d ONLN d f Ç ^ é Ö )Fdevelop ° d ONLN d n Ç Ö éà )';as part of their regular mailing; they have to subscribe to ° d ONLN d ™ é ö ? ( ∂ 6develop ° d ONLN d ≤ é ? öè )'Kto receive it in print. The mailing has been simplified to be just a CD-ROM ° d ONLN d ˛ ö ¶} ( ¬ 6Odisc and a 16-page publication in newspaper format that points to things on the ° d ONLN dN ¶ ≤Ä * Pdisc. Those developers who don’t want a lot of paper don’t have to deal with it; ° d ONLN dü ≤ æå * Tthose who do can order it. So Associates and Partners will cast their vote for paper ° d ONLN dÙ æ ? * develop ° d ONLN d¸ æ ? n )'Gby subscribing to it. (Letters from all of you expressing your opinions ° d ONLN dC æn x ( Êå— ° d ONLN dD ÷h ( Ú 6Fespecially when they agree with mine—are of course more than welcome.) ° d ONLN dã ‚ Ó2 *>Speaking of electronic media, those of you who were receiving ° d ONLN d… ‚2 ÓY (
Pdevelop ° d ONLN d— ‚Y Ó~ )'with its ° d ONLN d⁄ Ó ˙å ( 6SCD-ROM disc bound into it will notice that the disc corresponding to this issue has ° d ONLN d. ˙ Ç * Obeen packaged separately in its own case (made of partially recycled fiberboard ° d ONLN d~ ã * Tand plastic). This should put a stop to the problem of mangled discs. Also, the disc ° d ONLN d” ^ * is no longer the ° d ONLN d‰ ^ æ )FDeveloper Essentials ° d ONLN d¯ æ ˘ )` disc, but the ° d ONLN d ˘ X );Developer CD Series ° d ONLN dX Å )_
disc, the ° d ONLN d% *ê (F 6Qsame disc that Apple Associates and Partners receive. We hope this will make life ° d ONLN dw* 6ë * Xeasier for us and less confusing for you (not to mention that you’ll get more goodies on ° d ONLN d–6 B } * the disc than before!). ° d ONLN dËN Z} *NI’ll end with a vaguely related trivia question: What word was used instead of ° d ONLN d7Z fá * V“click” to describe the action of pressing a button on that first mouse? If you’ve got ° d ONLN déf rà * Rany good trivia questions of your own, send them along to us. We need all the help ° d ONLN d·r ~ I * we can get.
Caroline Rose ° d ONLN d˚·Ï2 * Editor v 4v& , Times
+˜q
+
3
(è 6SUBSCRIPTION INFORMATION *
4Use the order form on the last page of this issue to *
subscribe to )+ develop. ) Please address all subscription )i- (≠ 6related inquiries to )@ develop, ) Apple Computer, Inc., P.O. (∑ 6,Box 531, Mt. Morris, IL 61054 (or AppleLink *
DEV.SUBS).• (è ˜ BACK ISSUES *
%For information about back issues of )|develop ) and how (£ ˜4to obtain them, see the reverse of the order form on *
8the last page of this issue. Back issues are also on the *
Developer CD Series )I disc.•
4π Ú·Ø
+ö; EDITORIAL
)) Autumn 1991 ˇ8 ◊# ˇ ˇˇˇˇ # ◊
d , Helvetica
. ° d ONLN d i 5 { ç +SñLETTERS
° d ONLN d ñ $ ( @ ¥THREADS PACKAGING , Palatino ° d ONLN d ( ñ 4H *&I’m impressed with threads and futures ° d ONLN d A 4 ñ @B * (and I think they’ll be of real use to me ° d ONLN d j @ ñ LH * 'in a commercial product I’m working on. ° d ONLN d í L ñ XB * &I have a simple problem. I don’t think ° d ONLN d π X ñ d# * we can ship your INIT with our ° d ONLN d ÿ d ñ p6 * $application. Doing so constitutes an ° d ONLN d ˝ p ñ |+ * !unnecessary invitation to support ° d ONLN d | ñ à * hassles (as well as a just plain ° d ONLN d@ à ñ îF * 'unaesthetic package, in my opinion). Is ° d ONLN dh î ñ †& * there any chance that you could ° d ONLN dà † ñ ¨1 * !repackage the current threads and ° d ONLN d™ ¨ ñ ∏9 * 'futures stuff as straight libraries (in ° d ONLN d“ ∏ ñ ƒ * THINK C form, please)? ° d ONLN dÈ Ã ñ ÿ „ *—Richard Reich ° d ONLN d¯ Á ñ Û, *!The latest version of threads and ° d ONLN d Û ñ ˇI * )futures, which is on this issue’s CD, has ° d ONLN dD ˇ ñ A * $been augmented so that you have your ° d ONLN di ñD * 'choice of how to package the code. Just ° d ONLN dë ñ#2 * $use the INIT as is, or copy the code ° d ONLN d∂# ñ/C * 'resources into your application. Let me ° d ONLN dfi/ ñ;8 * "know if you need any more help. My ° d ONLN d; ñG * number is (408)974-0355. ° d ONLN dO ñ[ Ê *—Michael Gough ° d ONLN d)o ñ{+ * THREADS IN A BLACK BOX ° d ONLN d@ ñãA *'I was really pleased to see the article ° d ONLN dhã ñó ˝ * on threads in Issue 6 of ° d ONLN dÅã ˝ó' )g develop. ° d ONLN däã'óB )*There ° d ONLN dêó ñ£. (ø ¥!have been several instances in my ° d ONLN d≤£ ñØ" * programming experience on the ° d ONLN d–Ø ñª) * Macintosh when I had some long ° d ONLN dÔª ñ«I * 'involved processing that was not easily ° d ONLN d« ñ”+ * #restructured to pass control to the ° d ONLN d;” ñflC * 'interface or to other applications. The ° d ONLN dcfl ñÎ; * #Threads Package seems like the best ° d ONLN dáÎ ñ˜: * "way to handle this problem that we ° d ONLN d™˜ ñ+ * are likely to have without major ° d ONLN dÀ ñ * changes in the Macintosh OS. ° d ONLN dË ñ ' * However, I was disappointed to ° d ONLN d ñ+: * #discover that Semaphore, one of the ° d ONLN d++ ñ7A * %examples from the CD, crashes. If you ° d ONLN dQ7 ñCD * (click before the program is finished, it ° d ONLN dzC ñO> * )exits normally, but if you let it run its ° d ONLN d§ \ $È ( @z"course, it crashes after it’s done ° d ONLN d« $\ 0 * (beeping. I hope that a corrected version ° d ONLN d 0\ <È * of the Threads Package will be ° d ONLN d <\ HΩ * available on a future ° d ONLN d% <Ω H‰ )adevelop ° d ONLN d- <‰ Hˆ )'CD. ° d ONLN d1 L\ X
* #supplied with MPW; hence we have no ° d ONLN d≥ ƒ\ – * 'need for the source. Can we rely on the ° d ONLN d€ –\ ‹ * *same level of support for object libraries ° d ONLN d ‹\ Ë· * without source distributed on ° d ONLN d$ ‹· Ë )Ödevelop ° d ONLN d, Ë\ Ùt (zCDs? ° d ONLN d1 ¯\Ö *
I’ve seen ° d ONLN d; ¯Ö¨ ))develop ° d ONLN dC ¯¨ )'evolve from a journal ° d ONLN dY\˘ (,z!with good articles on programming ° d ONLN d{\ * 'techniques into a journal with articles ° d ONLN d£ \(ˇ * %that were basically blurbs for source ° d ONLN d…(\4 * !code, and now into a journal with ° d ONLN dÎ4\@ * (articles that are blurbs for black boxes ° d ONLN d @\L * !provided on the CD. I still think ° d ONLN d 6L\XÉ * develop ° d ONLN d >LÉX )' is an extremely useful resource ° d ONLN d ^X\d (Äz%for Macintosh programmers. However, I ° d ONLN d Ñd\p˝ * &urge you to try to include source code ° d ONLN d ´p\|√ * when you possibly can. ° d ONLN d ¬Ä\å¸ *#At any rate I am looking forward to ° d ONLN d Êå\òÎ * !seeing a corrected version of the ° d ONLN d
ò\§˝ * $Threads Package in a future issue of ° d ONLN d
-§\∞Å * develop ° d ONLN d
4§Å∞ )% —I intend to give it a try even ° d ONLN d
T∞\ºp (ÿzif it ° d ONLN d
Z∞pºz )is ° d ONLN d
]∞zº∞ )
a black box! ° d ONLN d
jƒ\–π (Ïz—Dennis C. De Mars ° d ONLN d
}ÿ\‰ *#You’re right, the Semaphore example ° d ONLN d
°‰\ * 'crashes, and it is a bug in the Threads ° d ONLN d
…\¸ * %Package. I guess I always clicked out ° d ONLN d
Ô¸\ * 'early during the final testing. Issue 7 ° d ONLN d \ * 'has a follow-up article to Threads that ° d ONLN d ?\ Î * includes an updated (and fixed) ° d ONLN d _ \,≠ * Threads Package.
4Npq6 v Bv/ (y 0
+
4
+Ç COMMENTS *
4We welcome timely letters to the editors, especially *
4from readers reacting to articles that we publish in *
develop ).. Letters should be addressed to Caroline Rose (∑ ¥(or, if technical )4develop )-related questions, to Dave (¡ ¥/Johnson) at Apple Computer, Inc., 20525 Mariani *
2Avenue, M/S 75-2B, Cupertino, CA 95014 (AppleLink: *
(CROSE or JOHNSON.DK). All letters should 4◊ Ø·q (çv0include name and company name as well as address *
4and phone number. Letters may be excerpted or edited *
2for clarity (or to make them say what we wish they *
did). )•
(Ú Dd )e )v )e )l )o )p )
) Autumn 1991 ˇå ◊# ˇ ˇˇˇˇ # ◊
d , Palatino
. ° d ONLN d ù +6< To address your concern about ° d ONLN d ù ¬ )Ödevelop ° d ONLN d & , ƒ ( H 6$heading toward “black boxiness”: The ° d ONLN d K , 8 ö * Threads Package is the only ° d ONLN d g , ö 8 ø )Çdevelop ° d ONLN d o 8 D … ( ` 6(article ever that hasn’t included source ° d ONLN d ò D P ´ * code. We debated for a long time ° d ONLN d π P \ œ * $whether that was OK, and many people ° d ONLN d fi \ h Œ * 'expressed the same concerns you did. We ° d ONLN d h t – * &decided that Threads was unique enough ° d ONLN d- t Ä ≥ * $and useful enough to justify it. The ° d ONLN dR Ä å à * (reaction has been extremely positive, so ° d ONLN d{ å ò £ * I think we did the right thing. ° d ONLN dõ ú ® à *'I assure you that we won’t make a habit ° d ONLN d√ ® ¥ – * *of featuring black boxes, and that as long ° d ONLN dÓ ¥ ¿ ∏ * !as Michael Gough keeps supporting ° d ONLN d ¿ à à * 'Threads, the latest CD will contain the ° d ONLN d8 à ÿ Õ * *latest version. Threads is not an official ° d ONLN dc ÿ ‰ » * (Apple product, though, so use it in your ° d ONLN då ‰ ¨ * "application at your own risk. It’s ° d ONLN dØ ¸ À * (possible that we will be able to publish ° d ONLN dÿ ¸ à * the source code someday. ° d ONLN dÒ *'Thank you for taking the time to write! ° d ONLN d $ ¢ * People’s comments are the best ° d ONLN d8$ 0 Õ * &barometer we have for how we’re doing. ° d ONLN d_8 D _ *
—Dave Johnson , Helvetica ° d ONLN dmU a ≈ * CD SETUP (AND MORE!) ON CD ° d ONLN dâe q ï *How about including on the ° d ONLN d§e ïq ≈ )} Developer ° d ONLN dÆq } F (ô 6
4~ ,Ç ˆ ° d ONLN dÙ ‚ R ( < EVASIVE SNIPPETS ° d ONLN d $ ‚ 0L *The Snippets section of ° d ONLN d $L 0s )jdevelop ° d ONLN d% $s 0ï )'always ° d ONLN d, 0 ‚ <è ( X %has such neat-sounding code fragments ° d ONLN dR < ‚ H} * (in it . . . if only I could find them! I ° d ONLN d{ H ‚ T7 * always peruse the ° d ONLN dç H7 Tñ )UDeveloper CD Series ° d ONLN d° T ‚ `Ç ( | $disc that arrives with each issue of ° d ONLN dΔ ` ‚ l * develop, ° d ONLN dœ ` lí )* but many of the snippets can’t ° d ONLN dÓ l ‚ xâ ( î $be found, either by my old-fashioned ° d ONLN d x ‚ Ñk * hand searching or by using the ° d ONLN d2 Ñ ‚ ê * HyperCard
° d ONLN d< Ñ êÉ + stack that, hopefully, ° d ONLN dT ê ‚ úà ( ∏ $really does have a complete index of ° d ONLN dy ú ‚ ® *
the contents. ° d ONLN dá ¨ ‚ ∏é *(It’s safe to say that it seems that most ° d ONLN d∞ ∏ ‚ ƒi * can’t be found. Assuming they ° d ONLN dŒ ∏i ƒx )áare ° d ONLN d“ ƒ ‚ –ë ( Ï #there—somewhere—I’d like to suggest ° d ONLN dˆ – ‚ ‹ä * &that the code you list in the Snippets ° d ONLN d ‹ ‚ ËU * section be included in the ° d ONLN d8 ‹U Ëz )sdevelop ° d ONLN d@ Ë ‚ Ùî ( )folder. Even a directory or stack in that ° d ONLN dj Ù ‚ Å * "folder that would point me to them ° d ONLN dç ‚ ~ * $would be a terrific savings in time. ° d ONLN d≤ ‚M * Keep up the good work! ° d ONLN d… ‚,& *
—Chris Gibson ° d ONLN d◊4 ‚@ë *$Snippets have had a rough time. They ° d ONLN d¸@ ‚LÜ * %didn’t make it onto the Issue 6 CD at ° d ONLN d "L ‚XÜ * #all. And, although they were on the ° d ONLN d FX ‚dè * &Issue 7 CD, they were not mentioned in ° d ONLN d md ‚pz * !the Contents Catalog stack on the ° d ONLN d èp ‚|è * %Developer CD Series disc. They can be ° d ONLN d µ| ‚àë * $found with the DTS sample code. That ° d ONLN d ⁄à ‚îé * &seems the most logical place for them, ° d ONLN d
î ‚†Z * since they’re not strictly a ° d ONLN d
îZ† )xdevelop ° d ONLN d
&† ‚¨ë (» $thing: they come from DTS (Developer ° d ONLN d
K¨ ‚∏É * $Technical Support); we just describe ° d ONLN d
p∏ ‚ƒã * $them (and we’ve decided to stop that ° d ONLN d
ïƒ ‚–ä (Ï 'they’re now described in a text file in ° d ONLN d
Ω– ‚‹v * !with the snippets). Sorry for the ° d ONLN d
fl‹ ‚Ë *
confusion! ° d ONLN d
Í ‚¸) *
—Dave Johnson ° d ONLN d
¯ ‚ ? *
ONE UGLY DUDE ° d ONLN d ‚,Ä *#I just wanted to comment that I was ° d ONLN d *, ‚8~ * totally shocked when I saw Harry ° d ONLN d K8 ‚D> * Chesley’s picture in ° d ONLN d `8>Dc )\develop ° d ONLN d g8cDx )% this ° d ONLN d mD ‚P (l month. x 4x& ({)
+
5 4ì Ú·Ø
(Úfl LETTERS
)$ Autumn 1991 ˇ ◊# ˇ ˇˇˇˇ # ◊
d , Palatino
. ° d ONLN d ñ $1 +¥@#“This is one ugly dude,” I thought. ° d ONLN d $ $ ñ 0D * %Perhaps his picture was sabotaged. Or ° d ONLN d J 0 ñ <I * &maybe he really is a Vulcan with three ° d ONLN d q < ñ H fi * Adam’s apples! ° d ONLN d Ä P ñ \ – * —Dan Wood ° d ONLN d ä d ñ pF *&Actually, that picture wasn’t supposed ° d ONLN d ± p ñ |A * *to be printed at all. It’s top secret, the ° d ONLN d ‹ | ñ à9 * &result of an internal Apple project in ° d ONLN d à ñ î5 * #the area of desktop bioengineering. ° d ONLN d' ò ñ §B *(But now that the cat’s out of the bag, I ° d ONLN dP § ñ ∞I * (guess I can mention that we’re expecting ° d ONLN dy ∞ ñ ºC * 'to ship the product second quarter next ° d ONLN d° º ñ »J * )year. It attaches to the SCSI port of the ° d ONLN dÀ » ñ ‘G * (Macintosh. You stick one of your fingers ° d ONLN dÙ ‘ ñ ‡= * 'in a hole in the front, and it modifies ° d ONLN d ‡ ñ Ï= * "your DNA. The actual physiological ° d ONLN d? Ï ñ ¯ * changes take about a week to ° d ONLN d\ ¯ ñ – * materialize. ° d ONLN di ñ Â *—Harry Chesley ° d ONLN dx ñ,J *'P.S. The three Adam’s apples are a bug, ° d ONLN d†, ñ8E * 'which we’re planning to fix in the next ° d ONLN d»8 ñD ® * rev. , Helvetica ° d ONLN dÕ \ $ ( @zWHERE'S LOUELLA, REALLY? ° d ONLN dÊ (\ 4 *)I sent mail to your predecessor, Louella, ° d ONLN d 4\ @ * #at louella@applelink.apple.com, but ° d ONLN d4 @\ L
* %your system denied knowing about her. ° d ONLN dZ L\ X„ * Any help you could give me in ° d ONLN dx X\ d * &addressing e-mail to her would be very ° d ONLN dü d\ p± * much appreciated. ° d ONLN d± x\ Ñú * —An Admirer ° d ONLN dΩ å\ ò¯ *$In Issue 7, I joked that Louella had ° d ONLN d‚ ò\ §˚ * $retired to raise flowers in Holland. ° d ONLN d §\ ∞ * (Well, I was close: she has left Apple to ° d ONLN d0 ∞\ º * $paint and write until her money runs ° d ONLN dU º\ »˛ * %out. We’ll miss her terribly but will ° d ONLN d{ »\ ‘ * $remember her always as our “Spirited ° d ONLN d† ‘\ ‡ * %Guide.” She’ll be living wherever the ° d ONLN dΔ ‡\ Ï * 'living is easy (and cheap), but letters ° d ONLN dÓ Ï\ ¯˝ * #will always get to her through this ° d ONLN d ¯\
* &address: 932 Rosette Court, Sunnyvale, ° d ONLN d9\ * 'CA 94086. Sorry, she will no longer be ° d ONLN da\ – * electronically plugged in. ° d ONLN d|$\0• *—Caroline Rose
4Vpr6
° d ONLN dçW üe~ (Ä ΩUPDATES TO CODE ON THE DISC "l Ø # l ∞l, "l- # "m Ø "m-
° d ONLN d™q ü| º *On the ° d ONLN d±q º| ) Developer CD Series ° d ONLN dƒq|Δ )S0 disc, the code that corresponds to articles in ° d ONLN dÙqΔ|Ë )∑develop ° d ONLN d¸qË|Ô )"is ° d ONLN dˇ} üà˘ (§ ΩUkept up to date wherever possible. Bugs that are reported are fixed, changes are made ° d ONLN dUâ üî˚ * Wto maintain compatibility, and so on. The latest CD always contains the most up-to-date ° d ONLN d≠ï ü† * versions of the code for ° d ONLN dΔï † )aall ° d ONLN d ï †2 )
issues of ° d ONLN d‘ï2†W )' develop, ° d ONLN d›ïW†ˆ )%*so if you’re going to use any code, get it ° d ONLN d° ü¨Ω (» ΩHfrom the most recent CD you have—even if the article is in a past issue. ° d ONLN dQ¥ üø ß *A ° d ONLN dS¥ ßøÎ )Onotable change on this disc is that the QuickTime example from Issue 7 has been ° d ONLN d£¿ üÀÙ (Á ΩTupdated to work with the beta release of QuickTime, and has a couple of new features ° d ONLN d¯Ã ü◊¸ * Vas well. Also, we’ve included the beta QuickTime extension, so you can try the samples ° d ONLN dOÿ ü„‰ * Qimmediately. (Remember, this is prerelease software that cannot be distributed or ° d ONLN d°‰ üÔ0 * %included with shipping applications.) ° d ONLN d«˜ üı *UAnother change we’ve made, to be sure we give you the latest possible information, is ° d ONLN d ü˚ * Zto include descriptions of code “snippets” on the disc itself rather than describe them in ° d ONLN d x ü ƒ * develop. ° d ONLN d Å ƒÙ )%LThe Snippets folder (which is in with the DTS sample code) now includes text ° d ONLN d Œ ü&Ù (B ΩXfiles that describe all of the snippets. The snippets are batched by date of release, so ° d ONLN d
'' ü2 * you can easily tell what’s new. é ØV Ø "W Ø # W ∞W, é-V- "W- # v Bv/
(y 0
+
6 4ëq·3
+od )e )v )e )l )o )p )
) Autumn 1991 ˇß ◊# ˇ ˇˇˇˇ # ◊
d , Helvetica
. ° d ONLN d + +-FC ° d ONLN d + % ) U ° d ONLN d $ + F )
RVE ° d ONLN d F + R )"S ° d ONLN d Q + U ) ° d ONLN d T + ë )AHEAD: ° d ONLN d 9 B I ë ( d `WORKING ° d ONLN d W " g ë ( Ç @ WITH CURVES ° d ONLN d " u Ö ë ( † 7 IN QUICKDRAW 0 0¨ ™
••Ñ•Ñ•Ñ•Ñ•Ñ•Ñ•ŸÑ/ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cш cÑ cÑ cÑ˛ c Ѹ cÑ cÑ˛ c ÑÓ c Ñ÷ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c
Ñ cÑ cÑ cÑ cÑ cÑ cÑ c˛ÑØ˛Ñ( cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ c˛Ñ c˛Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ cÑ cÑ cÑ˛ c Ñ˛ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ cÑ cÑ cÑ˛ c#Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ c˛Ñ cÑ cÑ c˛Ñ cˇÑ`ÑÑ cÑ cÑ cÑÌ c B¸ cB cB˛ c B˛ c B˙ cB cB cB˛ cB cB cB cB cB cB cB cB cB˛ c@B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB˛ cB cB cB cB cB cB cB cB cB cB cB˛ c B˛ c B cB cB cB cB cB cB˛ c B˛ c B˛ c B˛ cB cB cB cBÊ c •˘Ñ c˛Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ c Ñ” c B˛ c B˛ c B˛ c Bˆ c B˛ c B˙ c B˙ c B˛ c B˛ c B˛ c B˛ cB cB cB˛ c B˙ c B˛ c B˛ c B˛ c B˛ c B˛ c B˛ c B˛ c B˛ c B˛ c Bı cS˚Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˙ c Ñ˙ cÑ cÑ cÑ˛ c Ñ› cB cB cB˙ c B˛ c B˛ c B˛ cB cB cB˛ c B˛ c B˛ c B˛ c B˛ cB cB cB˛ c B˛ cB cB cB˛ cLB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB˛ c B˛ c s•Ñ•ÛÑ c¸Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ cÑ cÑ cÑÚ c Ñ˛ c Ñ˛ c ÑÅ cË c Ê˘Ñ c˛Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ cÑ cÑ cÑ˙ c Ñ˛ c Ñ— c B⁄ c B˙ c B˛ c B˙ c B˛ c B˛ c B˛ c B˛ cB cB cB˛ c B˛ cB cB cB˛ c B cB cB cB cB cB cB˛ cB cB cB˛ cB cB cB˚ cÑ c c ®•Ñ•ÛÑ c˛Ñ) cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ cÑ cÑ cÑ˛ c Ѹ c Ѹ c Ñí c ÑÍ c ‘Ñ•ıÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ cÑ cÑ˛ cÑ cÑÍ c Ñ˛ c ѵ c B˛ c B˛ c B˛ c B˛ c B˛ c B˛ c B˛ cB cB cB˛ cB cB cB˛ c B˛ c B˛ c B˛ cB cB¯ c B˙ c Á•Ñ•Ñ•˛Ñ •ÔÑ c˛Ñ c˛Ñ c˛Ñ c˛Ñ c˛Ñ cÑ cÑ cÑ cÑ c˛Ñ c˛Ñ! cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ c ш c Ñ˙ c Ñ˛ c Ñ˙ cÑ cÑ cÑ cÑ cÑ˛ c Ñ⁄ c •⁄ c Ñ˛ cÑ c ƒÑ•Ñ•˛Ñ •˘Ñ c˛Ñ c˛Ñ+ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ cÑ cÑ cÑ˛ c Ñ˛ c ÑΔ c Ñı c Bˆ c B˛ c Bfi c B˙ c BÙ c•Ñ˛•Ñ•Ñ•Ñ•€Ñ c˙Ñ cÑ cÑ cÑ cÑ c˛Ñ cÑ cÑ c¸Ñ c˛Ñ˝ cÑÑ cÑ cÑ cÑ˛ c Ñ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ѹ cÑ cÑ˛ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ c ÑÍ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˙ c ÑÚ cÑ cÑ cÑ cÑ c ≈ ••Ñ•Ñ•Ñ•Ñ•ıÑ c˛Ñ cÑ cÑ cÑ cÑ cÑ cÑ c˛Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ c˛Ñ c••Δ!5≠5≠=Ô=ÔJRB=Ô1å1å-k%) Á Á!ΔÑ•ÑÑ˙ c ÑÍ c Ñö c ÑM Δ˚•Ñ•˛Ñ •flÑ c˛Ñ c˙Ñ c˛Ñ c˛Ñ c˛Ñ c˝ÑL• Á-kJR^˜^˜c^˜^˜VµNsF1F1JRRîRîZ÷VµNsF1F1B=Ô1å)J! ÁÑÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c ш c Ñ˙ c Ñ˛ c Ñ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ cÑ cÑ cÑ˛ c Ñ cÑ cÑ cÑ cÑ c
••Ñ•Ñ•Ñ•Ñ•Ñ•Ñ•ÛÑ c˛Ñ c˛Ñ c˛Ñ c˛Ñ c˛Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ c˚Ñ ÁBco{súcVµRîRîNsF1JRRîRîVµVµRîF1=Ô1å1å5≠F1RîRîBF1=Ô5≠%)!ÑÑ˛ c Ñ˛ c Ñ˙ c Ñ˛ cÑ cÑ cÑ cÑ cÑ˙ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˙ c Ñ⁄ c Ñ˛ c ÑÊ cÑ cÑu•Ñ˛• Ñ•Ñ•Ñ•Ñ•Ñ•€Ñ c˙Ñ c˜Ñ#••1å^˜súwΩwΩg9^˜c^˜VµVµRîVµVµ^˜Z÷VµF15≠)J-k1åBJRF1JRB9ŒBRîNsB=Ô Á˛Ñ? cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ• Á!!%)%)! ÁΔ•˛ c;Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ c Ñ•˛Ñ •˛Ñ •ıÑ c˛Ñ& cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ c˚Ñ* Á5≠Z÷wΩ{fiwΩwΩkZkZZ÷NsF1Z÷RîRîNsRîVµVµB5≠5≠F1JRRîJRBF1RîRîF1=ÔF1F1JR=ÔB5≠ΔÑ c cÑ” cÑΔ!-k)J%) Á Á˝Δ Á%))J! Á Á•ÑÏ c Ñ˛ c ÑÍ cÑ cÑ cÑ˛ c Ñy˛•Ñ•Ñ•Ñ•˛Ñ •ÎÑ c˛Ñ c˛Ñ c˛Ñ c˙Ñ c˛Ñ c˘Ñ$•Ñ!Vµ{fiˇ{fiwΩwΩsúg9JR9ŒJR^˜VµRîF1BF1JR=Ô5≠=ÔF1JRRîJRJRBJRNsRîF1=Ô5≠9Œ˛5≠B=Ô-kΔ˛Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ cÑ cÑ cÑ˛ c Ñ cÑ cÑ cΔ!%))J%) Á Á˝Δ••Ñ˛• Ñ•Δ! Á ÁΔÑ cÑ˛ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cˇÑÑ•Ñ•ÌÑ$ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ c˚Ñ•Ñ!Vµ˛{fi)sú{fisúcJR5≠NsccZ÷NsRîRîF15≠=ÔF1BJRZ÷VµNsF1JRBB5≠-k%)%) Á!%))J1åJRF1Ns%)•ÑÑ˛ c Ñ˛ c Ñ· c Ñ%)! ÁΔΔ••Ñ•Δ•˝Ñ c˛Ñ cÑ c•ÑΔ ÁΔÓ c ÑÍ c Ñ˛ c Ñ˛ cÑ cÑV•Ñ•Ñ•Ñ•˛Ñ •˙Ñ •ÔÑ cÓÑ c˘Ñ$••-kcˇ{fiwΩ{fi{fisúcB9ŒZ÷súo{g9cg9VµB=ÔJRNsRîVµZ÷RîRîVµNsNsJR9Œ-k)J)J˛ Á Δ Á%)5≠BF1JR-k Á•˛Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ cÑ cÑ cÑ•)J˝!˛Δ Á•˙Ñ c˛Ñ c˛Ñ c•Δ!ÑÑ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cA••Ñ•Ñ•Ñ•˛Ñ •¯Ñ •˝Ñ c˛Ñ cÑ cÑ cÑ cÑ c˛Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ c˛Ñ cÑÑ• ÁF1súˇ{fi{fisú{fisúg9BB^˜o{g9g9^˜^˜F1=ÔF1NsF1JRRîVµRî˛NsJRB5≠5≠1å-k-k)J%)! ÁΔΔ Á Á!)J5≠1å-kΔÑÑ c cÑ‚ cÑ•%)!!ΔΔ•Δ••ÑÑ cÑ cÑ cÑ••ÑÑ cÑ cÑ˛ cÑÑΔ•ÑË c ѯ c Ѹ c Ñ˛ cÑ cÑ cÑE •„Ñ c˛Ñ cÚÑ cıÑ • Á=Ô{fiˇ{fi{fig9súwΩo{RîZ÷˛g9 ^˜Z÷Z÷JRJRVµJRBJRNs˝Z÷ VµB=Ô5≠=ÔBF1=Ô9Œ-k%)!!˝ΔÑΔΔ%)5≠B-kÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ cÑÑ%)!!ΔΔ••˝Ñ cÑ cÑ cÑ cÑ•Δ••˚Ñ c˛Ñ•Δ cÑ cÑ˛ c Ñ˙ cÑ cÑ cÑ˛ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑÑ «˛ c Ñ· c BÁ c ÑÑ9ŒwΩˇ{fisúo{^˜wΩwΩ^˜˛c ^˜^˜ccVµZ÷VµJRJRRîNsNsVµZ÷^˜VµF1JRF1BF1JRNsJR=Ô=Ô1å%)! Á˛•Δ!-k c•)J5≠ Áfl c
! Á%)ΔΔ••ÑÑ cÑ˛ cÑ cÑ cÑ cÑѸ•˝Ñ cÑ cÑÑΔ‘ cÑ cÑ ı¸Ñ cÑ cÑ cÑ cÑ cÑ˛ c Ñ÷ cÑÑ9Œo{{fi˛wΩg9o{{fikZg9g9kZ^˜cc^˜VµZ÷^˜VµRîNsJRNsVµ˛^˜Vµ^˜^˜RîNsVµZ÷^˜RîRîF19Œ-k%)!! ÁΔ• Á-kΔΔ1å-k)JѸ c B˙ c B˛ c B˛ c B˛ c B˛ c B c cΔ! Á!!Δ•˝Ñ cÑ c˛Ñ c˙Ñ˛•˛Δ••¸Ñ ΔÔ c B câ˚Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c Ñ˛ c Ñ cD•%)kZwΩwΩo{súo{c{fio{cg9kZ^˜VµRîRîJRNsVµRîJRBF1RîRîZ÷Z÷VµVµZ÷VµNsJRJRF1NsB9Œ1å1å5≠1å%)! Á Á••Δ%)!%)1å!%) Á c cB cB cB cB cB˛ c'B cB cB cB cB cB cB cB cB c ÁΔ!!Δ•Ñ•ÑÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ cÑѕѸ• Ñ˛•Ñ•B cB cB cB cB cB cB c˛B cB cB cB cB cB cB cB cB cB cB cB cB cB˛ c8 •˜Ñ c˛Ñ c˛Ñ c˛Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ˛ c&Ñ cÑ cÑ cΔ^˜wΩwΩkZkZsú^˜o{kZVµccVµNsJR=Ô=ÔF1JRVµRîF1BBF1NsJRJRRîZ÷Z÷Vµ˛Rî
NsF1F1B9Œ5≠-k%))J! Á••Δ˛ Á!1å!1å1å)J„ cÑ! Á!Δ¸•ÑÑ c˛Ñ c˛Ñ c˛Ñ cÑ cÑÑ˛•Ñ•˛Ñ•ÑÑΔ•˚ c Bˆ c B˛ c B˛ c BÔ cm˘Ñ c˛Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c ÑÓ c Ñ˛ c"Ñ c cBwΩsúsúRîkZZ÷Vµ^˜NsZ÷^˜VµNs9Œ9Œ5≠9ŒF1JRJRB=Ô=Ô9ŒF1JRNsRî^˜Z÷Z÷˛JR˛Rî
5≠ÑÑ cÑΔ1å5≠• cÑ cÑ c˚Ñë˝Ñ c˛Ñ( cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ c˛Ñ3 cÑ9Œ{fiF15≠=ÔJRNsVµVµZ÷RîRîJRF1BJRF1F1B9Œ1å9Œ9ŒBJRRîRî^˜^˜cZ÷^˜VµVµNsNsB9Œ5≠1å%)!! Á!•ΔΔ cÑÓ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˝ cB cBΔ%)9ŒJRF1NsNs5≠)J)J9Œ=ÔF1F1JR=Ô˛B˝F1BF1=Ô¸9Œ
1å-k!ΔÑ•Ñ••%)9Œ˛F1 =Ô=Ô9Œ5≠1å%) c• Á)JJRcc˝g9o{kZo{g9kZcB1å5≠BJRRîJRNs1åÑÑ cÑ cÑ c•Δ%)/Ñ cÑ“ c2Ñ c cÑo{súF15≠BJRRîVµZ÷VµVµRîNsJRF1F1JRJRF1=Ô9Œ5≠9Œ=ÔF1NsVµZ÷^˜^˜cZ÷VµRîRîJRF1=Ô9Œ-k-k)J)J••Δ•fi cÑ cј cB c c)J)J9ŒBJRF15≠%)-k9ŒF1NsF19Œ9Œ=ÔF1˛JRAF1BF1B9Œ5≠9Œ1å1å-k%)Δ••ΔΔ ÁΔ!-kBNsJRF1BB=Ô5≠1å)JΔÑΔ%)^˜cg9kZo{o{súkZcNsF19Œ=Ô9Œ=ÔNsZ÷Z÷^˜F1-kNs-kÑÑ c• Á1åF1g9súçÑÑ cÑ cÑÒ c B˙ c B˛ c B˙ c B˜ c F1{fio{F15≠=ÔJRRîVµRîVµRîRîJRJRF1JRBF1BB9Œ5≠5≠9Œ9ŒF1JRVµVµ˛Z÷
Ñ cÑ cÑ cÑ cÑ cÑ•Vµ5≠˙Ñ!%)Z÷^˜F1F1JRNs^˜JR9Œ=ÔJRNsVµZ÷^˜co{kZo{kZkZg9ccg9^˜Vµ9Œ9Œ5≠)J-k)J˘ c B¸ c'1å9ŒBZ÷ccZ÷RîRîVµZ÷kZZ÷^˜Vµg9Z÷ckZkZZ÷^˜RîVµRîB=ÔVµc^˜Rî5≠1å9Œ9ŒB9Œ ÁÑ•¸Ñ••ÑÑΔÑ˛•ÑÑ• Á Á)J)JJRsúsúo{súkZo{o{g9˝cB-k)J9ŒNsB)JBc5≠ΔΔ•• cÑ cÑÑ• cÑÑ•˛%)!ΔÑ c•Δ° cÑ˛ c Ѹ cÑ cÑ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ cÑ c Ácsú{fikZ1å˝-k1å1å5≠5≠˛=Ô9Œ• cш c Ñ˛ c)Ñ cÑ•Ns{fi{fi9Œ•ÑÑ•-kVµ{fi{fiNs=ÔJRNsNsZ÷c^˜c^˜cZ÷c^˜^˜ckZkZg9c^˜^˜cZ÷Z÷JR˛1å!%)9Œ)JB˛ c7B cB cB cB cB!1å5≠BRîZ÷Z÷VµZ÷Z÷cg9Z÷Z÷Vµg9cVµg9g9VµcVµRîRîB=ÔRîcZ÷Vµ9Œ1å%)%))J5≠9Œ1å• cB c cÑÑ•˛Ñ•ÑΔÑ˝ c•• ÁRîsú˝o{kZkZcc^˜^˜Z÷9Œ%)-kBNs1å-kVµg91å)J%)!ÑÑ cÑÑ!Δ˛ cBÑΔ Á1å1å˛ c •´˛Ñ1 cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ ÁkZsúˇZ÷-k)J-k-k1å1å5≠5≠=Ô9Œ=ÔB%) cÑ˙ cÑ cÑ cÑ cÑ c˝ÑNs{fiˇˇ{fi=ÔΔ1åJRg9wΩ{fi{fiB=ÔBNsNs¸^˜cZ÷^˜^˜Z÷cg9g9^˜^˜VµZ÷VµRîF15≠%))J%)!%)=Ô9ŒÑB˛ cB cB cB˛ c*Δ9Œ1å=ÔBRîVµRî^˜Z÷Z÷g9Z÷cZ÷g9g9Z÷^˜o{Vµg9^˜VµNsB9ŒRî^˜^˜RîB1å-kÑ••Δ Á Á• c c˝Ñ•Ñ¸•¸ cÑΔZ÷súsú˝o{g9c˛^˜!F1)J%)1åNsF11å9ŒkZRî-k-k9Œ1åΔΔ Á•!)J ÁÑÑ cÑ cÑÑ-k9ŒΔ•Ñ cÇ˙ c Ñ˛ c Ñ˛ c Ñ˛ c ѯ c Ñ cÑ c!o{{fiwΩNs)J˝-k1å1å5≠5≠9Œ9Œ1åÑÑÚ c Ñ˛ c&F1wΩˇ{fiˇ{fi{fisúwΩNsF19Œ9Œ=Ô9Œ9ŒBVµZ÷VµVµRîVµVµRîRîVµNsRîRîVµRîNsJRJRF1B1å)J˛ Á%)%)F1VµNs=Ô1å• cB cB cB cB cBÑ˛9ŒRî=ÔVµJRZ÷Vµ˛Z÷^˜^˜kZo{^˜RîcVµccVµJR=Ô=ÔJRc^˜RîF15≠5≠••˛Ñ c ÁÑ c cÑѕѸ• Ѹ c•1åg9o{o{sú˛o{^˜Vµ˛^˜=Ô-k%)9ŒRîF1)JJRg9F1%)1å5≠9Œ-k)J5≠-k1å1å ÁÑ cÑ˝ cÑΔΔ! c c≤
Ñ cÑ cÑ cÑ cÑ cÑ cÑ c˛Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ-kwΩ{fisú=Ô)J)J-k-k1å1å9Œ5≠˛9Œ ÁÑ˙ c Ñ˛ c
Ñ cÑ cÑ cÑÑ5≠súˇsú{fi{fi˛ˇ*{fiZ÷NsVµNsB5≠5≠=Ô=Ô5≠F1NsRîVµRîF1B=Ô=Ô9Œ1å)J)J!! Á ÁΔΔ•Δ Á%))J1åNscVµNsJRNs!˛ c B˚ c)-k9Œ9ŒJR9ŒF1F1VµZ÷RîcNsZ÷Z÷kZo{kZRîcZ÷cg9^˜JR=Ô=ÔJRZ÷^˜RîJR5≠B)J)J%)!•Ñ c! c˝Ñ˛•Ñ••˛Ñ c•Δ1åBkZo{˛sú o{o{^˜Z÷^˜cRî9Œ-k-kF1Vµ5≠1åc^˜1å-k9Œ5≠5≠-k5≠9ŒBZ÷Ns!Δ˝Ñ c cΔ cÑ Á•Ññ cÑ˛ c Ñ˙ c Ñ˛ c Ñ˛ c Ñ˙ c Ñ˛ c1åsú{fikZ-k%)-k)J-k-k5≠5≠9Œ5≠9Œ)JÑÙ c Ѹ cÑ)JBNsZ÷g9sú{fi˝ˇsúcVµRîF1-k5≠5≠9Œ-k9Œ=Ô5≠)J!!ΔÑÑ cÑ˛ c=ÑÑ•ÑΔ Á-kBJRJRBRîJR1å=Ô=Ô5≠• cB cB cB cB c Á9Œ1åF1=Ô=Ô5≠VµRîNs^˜Vµ^˜Z÷co{kZZ÷RîcRîccRî=Ô=ÔBZ÷Z÷VµJR9Œ=Ô%) Á˛%)
Ñ c•ΔB c cÑÑ•Ñ•Ñ•˛ cÑ Á=Ô9Œ9ŒkZsúo{súo{o{g9Z÷Z÷^˜VµF15≠1å9ŒVµF1-kBcJR%))J˛1å%)-k5≠NscNs-k%) Á••Ñ cÑ!Ñ c˛•¶Ñ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ cÑ cÑ9ŒwΩwΩc!˝-k1å1å9Œ5≠9Œ1å•˛ c Ñ˛ c Ñ˙ cÑ cÑ˛ c Ñ cÑÑ••!-kBRîg9o{wΩsúc5≠%)-k5≠1å5≠=Ô-k! Á ÁΔ cÑ cÑ c˝Ñ••Δ Á)J=Ô˛Ns9Œ9Œ5≠1å1å5≠)JΔ˝ c B˝ c!Δ-k9Œ=ÔB9Œ=ÔJRVµRîZ÷Vµg9^˜co{o{g9Ns^˜RîRîg9Vµ=Ô9ŒBRîZ÷VµNs9ŒB!˛Ñ•Ñ cÑ• c c˘Ñ˛ c•9Œ5≠!5≠súo{˛sú(kZg9Z÷^˜^˜Vµ9Œ1å)JBRîB)JRîc=Ô-k-k5≠1å)J1å9Œ=ÔNsg9B1å)J)J!)J•ÑΔ!Ñ c cΔ)JtÚ c Ñ˛ c Ñ˛ c Ñ˙ cÑ c=ÔwΩwΩB!)J˛-k1å5≠1å5≠5≠!Ì c B¯ cB cBÑ•!˛)JY=ÔB9Œ5≠=Ô%)!!ΔÑ•ÑÑ cÑÑ•Ñ•Δ Á%)1å9ŒRîRîNsF1B1å!%))J%)ΔÑ cB cB cB cB cΔ%)5≠F1B5≠=ÔBNsVµZ÷Z÷cc^˜o{kZkZZ÷Vµ^˜Ns^˜^˜=Ô9Œ=ÔRîZ÷VµJR=Ô=Ô1å c cB cB c cÑB c c˙Ñ5 c cΔ9Œ9ŒΔÑF1o{súo{súo{kZcZ÷VµZ÷Ns1å%)%)F1JR)J5≠^˜c-k1å=Ô=Ô!)J5≠B9Œ^˜c1å-k-k!1å1å%)Δ%) ÁÑ c c•1åÜ˛Ñ cÑ cÑ˛ c Ñ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ cÑ cÑ cÑB{fiwΩ%)%)˝-k˛5≠1å1åÑÑÙ cÑ cѸ c Ѹ cÑ cÑ˚ c BÑ%)JRNs5≠5≠-k!!ΔΔ•˝Ñ˛Δ !)J%)5≠=ÔJRRîZ÷NsF1B=ÔΔ˛• cÑ c cB˛ c B c c• Á1åBNs9ŒJR=ÔF1˛Vµg9^˜^˜o{o{kZo{RîcVµVµcF1=Ô=ÔJRZ÷VµNsB9ŒBÑ cѯ cÑ cÑ c˛Ñ ÁB1åΔ cÑJRsúo{˛sú(g9^˜VµZ÷Z÷F1-k!)JJR=Ô%)BcNs1å1åB1å-k-k1å9ŒJRg9Z÷5≠-k)J%)1å5≠ Á%)B1å cÑ cÑ%)c cÑј c Ñ˙ c Ñ˙ c Ñ˛ c
F1wΩc Á%))J-k-k1å1å5≠1å1å Áˆ c B˙ c BÚ c B¸ cÑ!˛)J-k%) Á•ΔÑ•Δ Á!%)%)1å9Œ1å=ÔF1BNsRîJR9Œ5≠-k Á˝ÑB cB cB cB cB c c•-k1å5≠=ÔBB=ÔZ÷VµRîc^˜Z÷˛o{g9cZ÷cNs^˜Rî=Ô5≠BRîVµNsF15≠RîÑÑ˝ c B˛ c B˝ c Ñ c cÑB-k• cÑÑRîkZ˛súo{g9˝Vµ#5≠)JΔBRî1å%)Nsc=Ô%)5≠1å)J)J1å1å=Ô^˜kZJR9Œ)J Á Á1å)J!-kVµ9Œ•ÑÑ c•ëÑ cÑ cÑ cÑ cÑ˛ c Ñ cÑ cÑ cÑ cÑ cÑ cÑ˛ c
Ñ cÑ c cJR{fi=Ô!)J-k-k1å-k˛1å-k• cш c ÑË c%Ñ•!%)-k5≠1å)J)J! ÁΔΔ Á!%))J-k5≠=ÔJRF1BVµJRBNsB-k!!•Ñ cÑ c cB˛ c,B cB c c•Ñ-k1å1å9ŒF1F1BBZ÷JRg9^˜Z÷kZsúkZkZg9Z÷c^˜VµcF19Œ=ÔRîZ÷RîJR9ŒJR-kΔÑÑ•Ñ˛ cÑÑ cÑ cÑ cÑΔ9Œ%)• cÑÑ ÁZ÷súo{súsúo{c˛Z÷$Rî1å%))JJRNs-k5≠^˜Z÷)J1å5≠1å%))J1å9ŒF1ccF19Œ5≠%))J-k)J Á5≠Rî9Œ!Δ cÑ cd˙ c ÑÚ c ѯ c Nso{%)!-k)J-k-k1å-k5≠1å! cÑBˆ c B˛ cB cB˝ c Á!-k1å5≠1å1å%)! Á Á!%))J1å1å9ŒBF1RîZ÷=ÔRîRîJRF1B%)ΔÑ˛ cB cB cB cB cB cBÑ ÁÑ%)5≠5≠1å9ŒF1B9ŒNsRîc^˜Z÷˛o{g9g9Z÷^˜cZ÷^˜Vµ9Œ9ŒJRZ÷RîNs9Œ=Ô5≠ Á cÑ• ÁÑ cB cB¸ cÑ1å!¸Ñ/)Jg9kZo{o{súg9^˜VµZ÷RîB1å!-kNs=Ô)J9Œg9Rî-k-k9Œ5≠)J)J1å1åF1g9cB1å-k)J5≠1å%)%)=ÔRî)J!ΔÑ cÑÉÑ cÑ˛ c Ñ˛ c Ñ˛ c Ñ cÑ cÑ cÑ cÑ cÑ cÑ˛ c
Ñ c cF1Z÷ Á)J-k-k)J-k˛1å-kÑÑ˛ c ш c ÑÚ c Ñ˘ c Á%))J˛1å)J%)˛!)J)J5≠9Œ=Ô=ÔNsNsRî^˜RîBJR=Ô9Œ-k Á c cB˛ c B˛ c B˛ c B c•-k c!5≠-k5≠5≠˛B F1JR^˜VµZ÷kZo{kZo{g9g9Nsc^˜Z÷^˜F15≠F1Z÷Z÷JR=Ô1åB!Δ cÑ Á!˝ c B˝ c• Á ÁΔΔ˛Ñ/-kcJRcsúo{g9VµZ÷Z÷Ns1å-k!BNs9Œ-k^˜cB)J=ÔB5≠-k5≠5≠9ŒVµkZNs9Œ-k%)!1å-k)J%)VµJR!! ÁÑÑ•à cÑÓ c Ñ˛ c Ñ˛ c Ñ˛ c F1=Ô Á)J-k)J-k-k1å-k1å Á¯ c B˙ c B˛ c B˛ c B˛ c B˛ c B˛ c B˛ c\B Á%)!)J-k)J)J%)!!%))J1å5≠=ÔF1NsF1RîNsVµZ÷F1F1=Ô%)•B cB cB cB cB cB cB cB c c!1å•Δ5≠-k5≠1åB=ÔF1=ÔF1Z÷Z÷VµkZkZo{kZkZcZ÷RîcZ÷^˜Rî5≠=ÔRîVµJR=Ô1åB!!Ñ cÑ Á•B cB cB˝ c˛Δ Á•ÑÑ=ÔkZ1å=ÔkZo{cVµVµZ÷B1å Á%)NsJR1å1å^˜^˜1å)J9ŒB%)-k˛9Œ^˜g9JR5≠%))J)J1å-k!1åRîNs!%) ÁΔ••w Ѹ cÑ cÑ˛ c Ñ cÑ cÑ cÑ cÑ cÑ cÑ˛ c Ñ cÑ c cB)J!-k)J1å-k˛1å)JÑ cÑÙ c ÑÁ c Δ-k!)J-k1å5≠5≠-k-k)J-k5≠=Ô9ŒBNsNsJRJRF1NsF19Œ-k Á c cB˛ cB cB cB˛ c B c cÑ%)9Œ•Δ1å1å-k5≠9Œ˛F1 =ÔVµZ÷VµkZo{kZo{kZg9cRîZ÷^˜RîZ÷B9ŒF1VµNsB-kB!%) ÁÑ c•Ñ c c˛Ñ˝ cÑ!!˛Δ,•^˜g9)J%)g9o{VµNs^˜Ns5≠-kΔ1åZ÷5≠%)F1g9Ns)J-k=Ô9Œ%))J9Œ9ŒF1g9^˜=Ô5≠)J-k1å5≠)J)J1å^˜9Œ Á!˝ ÁÉ cÑÙ c Ñ˛ c Ñı c B5≠Δ)J-k)J-k1å-k1å-k ÁÌ c B˛ c B˛ c B˛ c B˛ cCB cB cB cB•)J%))J1å1å5≠5≠9Œ5≠1å1å-k5≠9Œ5≠=ÔF1F1=Ô=Ô1å-k!•B cB cB cB cB cB cB cB cB c c-k9ŒΔΔ-k-k1å5≠=Ô=ÔF1F1=ÔRîcVµg9˛kZVo{g9^˜Z÷^˜Z÷VµVµRî5≠=ÔRîRîF15≠5≠%)Δ%)Δ•Ñ cBΔ c c•ÑB c cÑ•)JΔ••-kkZZ÷ Á9Œsúc9ŒJRZ÷5≠1å-kΔBB-k)JZ÷c-k%)5≠9Œ1å%))J9Œ5≠Z÷kZF19Œ1å)J)J9Œ-k)J%)Ns^˜1å•!Δ%))J!o Ѹ c Ñ˙ cÑ cÑ cÑ˛ cÑ cÑ cÑ˛ cÑ cÑΔ!)J-k-k˝1å-kÑÑ cш c Ñ c
%)-kRîZ÷)J!! Á%)5≠1åg c cB„ c Ñ%)-k)J-k-k1å-k1åΔÊ c B˛ cB cB cB˛ c B cB cBÑ Á-k Á%)-k1å1å˛5≠7)J)J-k-k1å-k)J-k%) ÁÑ cB cB cB cB cB cB cB cB cB c c• c)J=Ô%)Ñ)J1å)J-k5≠=ÔBBF1BccRîg9kZcg9g9c˝Z÷ c^˜Rî9ŒF1VµJR=Ô-k1åÑ Á˛!@•B cB cB cB cB c•)J1å)J-kcg95≠F1súc9Œ-kc5≠•• ÁÑ%)-k-k=Ôg9=Ô!)J=Ô1å-k!1å5≠JRg9Z÷9Œ5≠%)!)J1å)J%)1å^˜Ns%)%))J Á)J9ŒBa ÑÚ c Ñ˛ cÑ cÑ cÑ˛ cÑ cÑ c c•)J)J-k-k1å-k1å)JÑ cÑ˛ c Ñ⁄ c Á%))J Á)J)J-k%)˛)J Á!%)!%)%)!ΔÑ cB cB cB cB˛ c B˛ c B˝ c•ÑÑ)JF1%)• Á9Œ)J-k1å=ÔBBF1=ÔZ÷g9Vµ˛cg9g9c^˜VµcRîc^˜Z÷B=ÔRîRî=Ô1å1å•Δ%) Á!• cB˛ c B˝ c5Ñ•)J=ÔBkZZ÷BkZo{Rî ÁJRc! cÑ••Ñ-k-k=ÔVµ)J%)9Œ9Œ)J Á!)J5≠Vµg9Ns1å-k%))J5≠5≠-k)J=ÔZ÷BΔ)J!!-k=ÔBt˝ c BÊ c BΔ)J-k)J-k-k1å1åΔÒ c B¯ cB cB cB˛ c B˛ c B cB cB cB cΔ%))J%) Á%)%))J! ÁΔ Á•Δ••ÑÑB cB cB c˛Bi cB cB cB cB cB cB c•Ñ c-kB1å•Δ1å-k)J-k=Ô=ÔBF1BRîccVµg9g9kZkZg9Z÷Vµ^˜RîZ÷^˜VµRî5≠JRRîF11å5≠••! Á Á•B cB cB cB cB cBÑ)J9ŒJRg9NsZ÷o{Vµ%)%)Z÷=ÔÑ c c•Ñ cB•9Œ)JÑ%)=Ô9Œ!Δ)J1å=ÔkZc=Ô5≠˛-k
5≠5≠)J%)JRVµ1åΔ-k%) Á-k5≠Bs ÑÙ c Ñ˛ cÑ cÑ cÑ cÑ cÑ cÑ cÑ c c Á-k)J-k)J1å)J)JÑÑ˛ c ј c B‰ c•%)%))J)J%) Á˛%)!! ÁΔÑÑ c cB cB cB cB cB cB cB cB cB˛ c4B cΔ Á•Ñ!F15≠Δ•-k1å)J-kB=ÔBBF1JRg9g9Z÷^˜kZg9kZg9^˜VµVµZ÷Rî^˜Z÷VµF1=ÔRîJR1å5≠ΔÑ!! Á• cB cB˛ c B˝ c3 Á5≠cZ÷Z÷cg95≠ Á9Œ9ŒΔÑ c• cÑ c c)JJRÑÑ Á=Ô9Œ Á•%)1åVµg9Vµ9Œ5≠%))J1å=Ô-k%))JZ÷Vµ)J!-k!!-k9Œ=ÔÅ c cBÛ c ÑÚ c !˛)J-k-k1åΔÑÛ cB cB˛ c B˛ c B˛ cB cB cB˛ cB cB cB cB cB-k1å%))J)J-k-k Á˛%) !! ÁΔÑÑ c cB cB c˛BE cB cB cB cB cB cB cÑ)JΔ• c!B9ŒΔ• Á1å%)1å9Œ=ÔBB=Ô9ŒZ÷c^˜Z÷g9kZg9kZ^˜VµRîVµF1VµZ÷Z÷Rî9ŒJRRî5≠1åΔÑ•%)Δ•B cB cÑ cB cB˛ c ÁNsg9VµJRg9c-k Á1å)J•BÑΔÑB c cZ÷5≠˛ c•)JÑ•Δ5≠Z÷kZVµ1å-k1å%)=Ô5≠-k!1åVµNs%)!-k Á Á-k5≠=Ôe ш c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˝ c !)J)J-k)J1å)JÑ cÑ cј c B„ c BB=Ô%)-k1å1å5≠1å%)%)!˝%)
Á•Ñ c cB cB cB cB cB˛ c B˛ c
B c c)J-k Á•Ñ ÁBB)JÑ!˛-k9Œ=Ô˛B"9ŒF1cg9Z÷g9g9kZkZg9VµVµJRJRF1^˜Z÷Z÷JRBNs9Œ1å%)Ñ•%) Á• c cÑ cÑÑ˛ cBÑB%)Bo{JR=ÔkZZ÷!%)1å5≠ cÑ c• c cB%)Z÷•˝ c••Ñ)JRîZ÷g9=Ô)J%))J1å1å5≠!)JBc=Ô Á-k5≠ Á!-k5≠=Ôé c cB cBÊ cB%)%)-k)J)J-k Á˛ c ј cB cB˛ c B˛ c B˛ c B˛ c B˛ c B˛ cB cB cB cBRîF1)J-k5≠9Œ=Ô5≠1å)J)J!)J%))J! ÁÑ cB cB cB cB cB cB cB cB cB cB Á1å5≠ Á•ÑΔ=ÔF1!• Á-k)J-k5≠B9ŒB=ÔB5≠Z÷g9^˜^˜kZcg9cZ÷VµJR=ÔBNsZ÷Z÷Vµ=ÔNs=Ô-k)J•Ñ%)Δ• cÑ cÑ cÑB cB cB cΔVµg9F1RîsúJR!)JNs Á cÑ•• cB c5≠-kB c B cBÑÑ cΔ-kBkZ5≠ Á Á!1å5≠)J!!JRVµ1å Á5≠1å Á Á-k5≠9Œc ѯ c Ñ˛ c Ñ˛ c ѯ cÑ cÑ c c!-k)J-k-k%) cÑ cÑ˙ cÑ c cB‡ c ^˜Rî-k1å5≠=ÔBB9Œ1å)J)J˝%) Á ÁÑ˛ cB cB cB cB cB˛ cB c c•-k9Œ5≠!˛• =ÔF1%)•Δ)J-k)J1åB9Œ=Ô˛B =Ôg9c^˜kZg9cg9^˜Z÷F19Œ5≠BNs^˜Z÷JRBJR%)1å••%)!ΔÑ cÑ˝ c B c cÑ cΔkZZ÷1åRîkZB!BNsΔÑ•Δ%) c cÑ%) c cB cB cÑ•˛ cÑ^˜5≠• Á Á9Œ9Œ Á!)JZ÷Rî! Á9Œ-kΔ!)J1å5≠ã c cB cB c!%))J)J-kÑÙ cB cB cB cB cB cB cB cB cB cB˛ c B˛ c B˛ c6B cB cÑcRî1å5≠9ŒBF1=Ô9Œ1å1å-k-k)J)J! Á5≠ΔB cB cB cB cB cB cB cB cB c Á1å=Ô9Œ!ΔÑÑ9ŒJR1åÑÑ˛%)a)JB5≠BBF1F1=ÔJRg9Vµg9g9cg9cVµNs9ŒBNsNsRîZ÷Rî=ÔJR)J-kΔÑ)J!Δ c• c cB cB cB c• c!o{F1!^˜g9-k1åVµ9ŒΔÑÑ Á)JÑB•Ñ cB cB cB• c cB cBVµ!Ñ c Á5≠-kÑÑJRc1åΔΔ5≠%) Á!-k1å9ŒeÑ c cB˘ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˝ c!)J)J-k!Ñ cј c B˙ c BÁ cΔg9Z÷1åBB˛F1=Ô=Ô5≠˛1å-k-k)JJR Á cB˛ cB cB cB cB cB˝ c5%)5≠B=Ô)J•ÑÑ1åNs9ŒÑÑ)J-k%))J=Ô9Œ=ÔBF1F1JR=ÔVµcZ÷kZg9kZcVµRîF1BRîJRNsNsVµJR=Ô-k-k•Ñ)J-kΔÑ• cÑ˚ cÑB=ÔkZ1åΔc^˜1åRîg9%)ΔÑΔÑ)JÑ cÑÑ c cB˛ c )J˛ cBBF1 ÁBÑ c•ΔÑÑVµF1=ÔΔ!1å Á!%))J9Œ=Ôç c cB cB c %)˛)J Δı cB cB cB cB cB cB cB cB˛ cHB cB cB cB cB cB cB cB cB c•g9^˜1åBJRF1JRF1F1BB9Œ9Œ5≠1å1å^˜F1)JB cB cB cB cB cB cB cB cB c%)9Œ=ÔB%) ÁÑÑ)JB5≠• c-k1å)J)J˛9Œ"=ÔBBJRF1Bg9Vµg9kZg9cVµRîJRJRBJRRîZ÷BRî9Œ9Œ)J• c%)-k Á•Δ cÑB˛ c7B c cÑRîg9 ÁΔg9Z÷JRo{NsΔÑ cΔÑ• cB c cÑB cB c c1åΔ cB cBB c cB cBÑÑ Á5≠%)BΔ!)J•!!)J1åBgÑ c cB˜ cÑ cÑ cш c Ñ c c%))J)J%) cÑ cÑ cѸ cÑB cB¸ c BÊ cYBΔg9kZ1åJRNsRîJRNsF1B=Ô=Ô1å5≠9Œg9cB1åÑ c cB cB cB cB cB cB cB c c-k9ŒF1B)J Á•ÑΔ5≠=Ô••-k=Ô)J)J5≠=Ô9Œ=ÔBF1F1Ns=ÔNsVµcg9kZcZ÷RîRîJRZ÷^˜^˜NsBF15≠1å)JÑ•!1å ÁΔ˝ cÑÑ˛ cÑ•^˜c Á ÁkZRî^˜g95≠•ÑÑ Á cÑ˛ c •¸ c• ÁΔB˛ c )J¸ cÑ• Á•ÑΔ c ÁΔ•!%)-k5≠9Œá c cB cB cBÁ c%)%))JΔˆ cB cB˛ cB cB cB cB cB˛ c B˛ cB cB cB cB cB˛ c B˛ c+Δg9o{9ŒF1RîNsNsJRJRF1B9Œ=ÔVµo{cVµB5≠Ñ cB cB cB cB cB cB cB cB c-k=ÔBF1)J!˛•5≠B ÁÑ!=Ô-k)J˛5≠79ŒBBJRJRF19ŒJRVµkZg9cZ÷VµRîRîF1BB=Ô5≠1å Á!!ΔΔ Á1å!•Δ•Ñ cÑ•ÑB c c!^˜^˜•!cRî^˜Rî ÁÑÑ Á ÁÑ˛ cΔ! cB cB cÑ• c cB c cÑB˛ cBÑ•ÑB˛ c•Ñ• Á!-k5≠=Ôf˛ c B˝ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˝ c!)J%)Ñ˛ c Ñ˛ cÑ cÑBˆ c BË cB ÁcsúF1JRRîVµRîNsJRJRBRîo{wΩcg9VµF1=ÔΔ˝ cB cB cB cB cB˝ cP1å=ÔF1F11å!ΔÑ•1åJR!Ñ!F15≠%)1å9Œ5≠=Ô=ÔF1F1NsJRJRBRîg9c^˜^˜RîRîZ÷Rî)J9Œ=Ô5≠)J!! Á! ÁÑ1å Á Á!%) Á•• Á• c cÑ ÁcVµ•%)kZVµZ÷1å!•)J-k)J• c c•5≠)J¸ cÑÑ˘ cÑ c• Á•˝ cÑΔ cΔ Á!-k9Œ=Ôä c cB cB cBÁ c%))J Á˜ cB cB˛ c B˛ cB cB cB˛ c B˛ cB cB cB cB cB cB cB cB cB c ÁZ÷o{NsJRVµRîRî˛Ns2^˜wΩwΩg9kZcRîF1=ÔΔ cB cB cB cB cB cB cB cBÑ-k=ÔBJR-k%)•ÑÑ1åB)JÑΔ9ŒB%)-k5≠5≠9Œ=ÔBB˛JR5BJRVµNsRîRîNsNsVµVµ9Œ%)5≠5≠)J Á!Δ!Ñ c-k! Á)J%)%)!! ÁΔÑ c c%)cJRÑ)Jg9Z÷F1!-k=Ô1å5≠1å•BÑ)JZ÷ Á˝ c˛ÑB cB cB c cÑB c)J=Ô c cB cB Á c c• Á!-k1å=Ôa cB cB cBı c Ñ˙ c Ñ˚ c%))JÑÑ cÑ˛ cÑ cÑBŸ cZ%)RîsúRîJRVµVµRîVµ^˜súwΩo{kZkZccRîNsB! c cB cB cB cB cB cB cB c c1å=ÔF1JR5≠!Δ• Á-kJR5≠Δ•-k=Ô-k5≠5≠1å9Œ9ŒBBF1JRJRF1BF1NsNsRîNsVµ^˜^˜B5≠)J-k)J!Δ•• cB-k!!)J)J˝%) Á• cÑ)JkZ9Œ Á1åg9^˜JR ÁB=Ô1å1åBÑ c ÁNs9ŒÑ cÑ c cÑÑ c cB˝ cÑ c cÑ-kJRÑ cÑ cÑÑ c c• Á%)-k1å5≠ô c cB cB cBˆ c BÙ cB! Á¯ cB cB˛ c B˛ cdB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c%)RîkZVµF1RîVµcsúwΩkZg9g9^˜VµcVµZ÷NsB! cB cB cB cB cB cB cB cB c)J=ÔBJR9Œ%)Δ•Δ)JB5≠Δ•%)B1åF1-k1å5≠9Œ=ÔBBF1BJRB=ÔB˛F1JRB5≠1å)J1å%)%)•˛Ñ BB)J%)%)-k%))J%)%))J!Ñ c c5≠g9)J!9Œc^˜9Œ!!-k•1åBÑ•=Ô Á˛Ñ cÑÑ)J• cB cB c• ÁÑ cBΔ)J9ŒÑ cB˝ cΔ• Á!-k1å=ÔT˛ c B˝ c Ñ˙ cÑ cÑ˙ c Ñ˚ c Á• cÑ˛ cÑ cÑ÷ c-kNskZVµBZ÷o{wΩo{cc^˜VµRîZ÷Z÷cRîRîJR Á˝ c6B cB cB cB cB cB c c)J=ÔF1JRB%)!••!JR9ŒΔÑ!B=Ô=Ô5≠-k5≠5≠=ÔBBF1BF1F15≠F1F1=Ô9Œ1å)J)J Á!%))J•˛Ñ c cB˛)J -k)J Á!)J)J ÁÑ cÑ9Œc Á)J=Ôg9c5≠-kΔÑÑ)J-k c!• cÑ˛•ÑÑ1å Á˝ c•-k ÁÑ c c ÁF1 Á˝ c Ñ cÑ)J! Á%))J1å=ÔÉB cB cB cBË cBΔ˘ cB cBÚ c B˛ c B˛ c^B cB cB cB cB cB cB cB cB c1å^˜kZVµ^˜súg9cZ÷VµNsNsRîZ÷^˜^˜Z÷VµRîJR• cB cB cB cB cB cB cB cB c%)=ÔF1NsB%)%)Δ•!BBÑÑΔ9Œ1å=Ô9Œ9Œ5≠5≠9ŒB=ÔBB=Ô9Œ9ŒB-k!!Δ• cÑ c˛ÑGΔ Á c cBB Á)J%)%)Ñ c Á-k!• c cÑNsc!-kNsg9c=Ô1åÑ cÑ!Δ cÑ cÑ••Δ••Ñ%)Δ cB•Ñ5≠ ÁΔÑ c c•5≠ÑB cB cB cÑ=Ô=Ô Á!)J5≠BP¸ c B˘ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ cÑ cÑ cÑ cÑB’ c=ÔsúkZkZsú^˜c˛Rî VµZ÷^˜Z÷Z÷^˜Z÷VµZ÷B˛ cB cB cB cB cB˛ c"B cΔ-k5≠F1JRF1%)! ÁÑΔ=ÔF1!Ñ•1å)J1å1åF1RîJRJRBB=ÔB-k!Δ•Ñ˚ c(ÑΔ!Ñ%)Δ cB cÑ ÁΔ• c cBΔ1åΔÑÑ c•9ŒF1Δ5≠Z÷o{g9F11åÑ c Á••Ñ cÑΔ˝ Á••Δ• c c Á!-k• Á c c•Ñ•˙ c ÁBRî Á%))J9ŒF1{B cB cB cB‡ cB cBˆ c B˛ cB cB cB˛ c"B cB cB cB cB cB cB cB cB c c-ko{wΩkZwΩ^˜kZVµZ÷Z÷cg9cZ÷cZ÷˛Vµ/Rî%)B cB cB cB cB cB cB cB cB-k1å5≠F1JRNs-k Á••Δ5≠B-k•Ñ1å-k Á-k)J9Œ9Œ1å)J%) Á•Ñ˛ c Ñ˝ c*BÑΔΔ Á•!ÑB cB Á ÁÑB cB c Á)JÑÑ c cÑ••Ñ5≠cNsJRF19Œ c cÑ•Ñ c cΔ Á˛!Δ• cÑ c cÑ%)!•ΔΔB•ΔÑB cB˝ cÑ ÁJRVµ!!-k9ŒF1J˛ cB cB c cѸ cÑ cш c ѯ cÑBı c Ñ„ cB9Œsú{fio{wΩo{kZ^˜RîZ÷^˜Z÷c^˜ccg9Z÷Z÷VµRîѸ cB cB cB˛ c B c cÑB=Ô5≠F1JRRî5≠! Á•Δ5≠JR9Œ••!9ŒΔ!-k%) Á Á•Ñ˘ cB cB c•˛ ÁΔ!˛ cÑ%) Á c cB cB1å! c cÑÑ•˛Ñ!9Œ=Ô)J-kRî9Œ• c%)•Ñ cÑ Á!!)J%)!Ñ cÑÑ c• ÁΔ c!•Ñ!!Ñ˝ c Ñ cÑ•%)JRVµ!%)-k=ÔF1ÄB cB cB cB‚ cB cBÚ c7B cB cB cB cB cB cB cB cB cB cB cB cB cB=Ôsú{fio{wΩsúkZkZRîRîVµVµZ÷Z÷cc^˜Z÷g9^˜cJRÑB cB cB c˛B% cB cB cB c!RîB9ŒBNsNsB!%)ΔΔ!F1-kÑ cÑ Á ÁΔ%)Δ• c cB cB cB˛ c˛B cB••!Δ Á! cB c Á-k c cB cB c1åΔB• c•˛Ñ2Δ5≠%)Δ-kVµJRΔ•=Ô• c••)J%))J)J%) Á cB•Ñ c cÑÑ•!ÑΔ%))JÑB c cÑ c c%) Á%)9ŒVµ%)!1å9ŒJR^˛ cB cB˘ c Ñ˙ c Ñ˛ c Ñ˛ c Ñ˛ cÑ cÑÙ c ÑÎ c B¯ c=ÔsúsúwΩwΩkZg9Z÷NsJRRîZ÷g9kZc^˜co{ckZg91å˚ cB cB cB cB˝ cBcZ÷=ÔBJRRîF1-k%) Á•!-k)J˛ cΔ ÁΔ•Ñ c cB cB cB c cÑ c cB cB c•Δ!• Á!˛ c-k! cB c cÑ c-k• cBÑ•ÑÑ••9Œ!-k5≠Vµ=Ô!)JJR˛•Ñ•!˛%) ! cÑΔ• c cÑ c! Á c)J%)1å Á c cÑ•Ñ•1å•5≠)JF1!%)-kF1JRÅ c cB cB cB‚ c Bˆ c B˛ c B˛ c(B cB cB cB cB cB cB cB cB cB cB cB cB1åJR^˜kZo{kZcNsF1JR^˜g9g9ckZg9˛kZ^˜VµΔ cB cB c˛B cB cB cB c c•Z÷wΩkZJRBNsRîRî)J!˛Ñ Á ÁÑB c cÑ˛B cB cB cB c c•Ñ cB c˛B2Δ•!Ñ! Á cB•-k•B cB c• c•ÑB c cÑBÑ• Á=Ô)J1å=ÔVµF1-k%)ΔΔÑ c•ÑÑ•• Á!ÑΔ Á•Ñ˛ c)J••5≠!Δ-kB c•• c Á5≠Δ9ŒB-k!•)JBJRj˛ cB cB˜ c Ñ˛ c Ñ˛ c Ñ˛ c Ñ˛ cÑ cѸ c Ñ˛ c Ñ„ c B˛ c B˛ c ÁVµRîF1kZg9Z÷F1B1åBg9kZkZg9o{o{kZ^˜kZBÑ c cB˛ cB cB cB¸ c!o{{fi{fiZ÷BJRNs9Œ Á•• cÑ• ÁÑ cB cÑ•˚ c B˛ c)ÑÑB cB cB cΔ•ΔÑ! Á c c!-kÑ cB cB c cÑB cB c cΔΔ!!F1-k-k5≠=Ô5≠ Á˛•' c•%)!%)! ÁΔ%) cÑÑ•ÑÑ cΔ)JÑ!=ÔΔÑ Á c c ÁÑÑ-k5≠ Á=Ô^˜9Œ• c!F1F1yB cB cB cBÁ cÑ c cBÓ c B˛ c B˛ c B˛ cLB cB cB cB cB cB cB cB cBRîRîVµZ÷Rî9Œ-kÑ)JcckZo{g9cckZRîΔB cB cB cB cB cB cB cB c c9Œ{fiˇ{fikZ=Ô9Œ)J-kΔÑ c cB• Á• c c•%)!ÑB˛ cB cB cB cB c˛B c cΔ˛ c %)Δ cB-k Á cB cB˛ c
B cB cÑΔ•ΔΔ Á1åΔB c˛B cB c c•ÑΔ!)J%)Δ ÁΔ• c cÑÑ%)-kΔ c=Ô=Ô•˛ c•ΔÑÑ=Ô Á)J9ŒcRîÑ c%)F1Be cB cB cB˘ c Ñ˙ c ѯ c Ѹ c ÑÓ c ј c B˛ c B˛ cB cB cB c c!RîcBVµJR9Œ•Δ)Jc˝g9cg9c)JB cB˙ cB cB cB˛ c RwΩ=Ô%)%)!ΔÑ˛ c*•5≠1å• cΔ)J Á c cB cB cB cB c c•Ñ cB cBΔ• cBÑ%)ΔB•-k•B cB c c ÁÑ˛ c&•Δ c cÑ• c cB cB cB cB cB cB cB c cÑÑ•!!Ñ cÑ1å!Δ c ÁJR5≠Ñ˛ c Á!ÑΔ5≠•5≠=ÔccΔ c-kF1-kÉB cB cB cB˛ c BÚ c B˙ c BÓ c B˛ c B˛ c<B cB cB cB cB cB cB cB cB cB cB c cBZ÷JRRîF1!ΔΔ1å^˜kZkZg9^˜g9kZ=Ô c cB cB cB cB cB cB cB cB cÑc{fi˛ˇ JR%)Δ!Δ•ÑÑ cΔ1å-k˛ c(•Ñ cB cB cB cB c cΔΔ•B cB c ÁÑB cÑ%)ÑB Á)J c cB cB c)JΔB c c•˛B cB cB c˛B cB cB c˛B cB cB cBÑ•Ñ cΔ•ÑÑ c-kNs!˝ c! ÁÑ Á ÁÑB9Œ^˜g9!Ñ=Ô5≠Ñn˛ cB cB˘ c Ѹ c Ñ˛ c Ñ˛ cÑ cÑ c cB c cÑ˛ c Ñ„ c B˛ c B˛ c B˛ c
B c!RîZ÷JR9ŒΔ• Á=ÔkZg9g9˛kZJRѸ c B˛ cB cB cB˛ c BΔ^˜kZo{{fi{fiZ÷Δ Á%)9Œ Á ÁÑÑ cΔΔÑB cÑ ÁÑ c cÑ cÑ˝ cÑÑ c cB c•ΔB cBΔ%)Ñ c%)%)˛ cB c c1å Á˛ cB cB˛ c2B cB cB cB cB cB cB cB cB cB cBÑ c•• cÑÑ•BF1••Ñ c•%)! cΔ c ÁB=ÔRîkZ%)!F1-k cÄB cB cBB˜ c BÚ c Bˆ c Bˆ ccB cB cB cB cB cB cB cB cB cB cB cB cB cB cBÑ5≠^˜Ns9Œ!ΔΔRîg9o{kZkZcZ÷• cB cB cB cB cB cB cB cB cB c•JRRîZ÷^˜kZVµ Á-kB9Œ!ÑÑB c c ÁΔ cB!1å! cÑÑ cB cB cB cB c˛B Δ cBB c•%)ÑÑ%)!B c˛B c%)ΔB cB cB cB˛ c˛B cB cB cB cB c˛B cB cB˛ cÑÑ cÑÑ%)JR5≠ c)J! c Á)JΔ˛ c !JR9Œ9Œ^˜)J-kBΔ c_ cB cB cBı c Ñı cB c cÑfl cB cB cB˛ c B˛ c B˛ cBÑBNs=Ô! Á5≠g9kZckZRî!Δ cB cB cB˛ c"B cB cB cB cB c c•=ÔF1JRRîNsNs1å9Œ1å!•Ñ c cÑ)JJR9Œ•Ñ!1å!˛ cB cB cB cB˛ c B˛ cB cBΔ%)ÑÑ)J•˛ cB c c ÁÑ˛ cB c cÑ˝ c0B cÑ cB cB cB cB cB cB cB cB c cÑÑ••Δ1åNs%)•ÑB Á!)J• c cÑ9ŒB=Ô-k9Œ1å5≠1åÑB{B cB cB¯ c BÚ c Bˆ c Bˆ c B˛ c&B cB cB cB cB cB cB cB cB cB cB cB cB cB cBÑ5≠F1-k-kVµg9cc1å˛ c B cB cB cB cB cB cB cB cB cB c c1å=ÔBF1F1B1å)J!˝ ÁΔÑ%)=Ô1åÑ c c•ÑB cB cB c˛B˛ cB c˛B cB cΔ%) c•)JΔBÑ c cB cÑ˛ cBÑÑ Á Á cB cB˛ cB cB cB c˛B" cB cB cB cB cB cÑΔΔ5≠=Ô ÁÑ c•!)J1åÑ c c ÁF1F11åF1!)J9Œ!ˇ cZ˛ c Bı c ÑÚ c ÑÁ c B˛ c B¸ cB cB cB cB˛ cB cB cB cB cB cΔ1å9ŒNsVµ=ÔΔ˛ cB cB cB cB cB˛ cB cB cB cB˛ c)J=Ô=Ô˛B -kΔ!=Ô5≠-k%)• cÑΔΔ˛ cÑÑ˛ cB cB cB cB cB cB cB cB cB!)J•Ñ-kÑ cÑ•˛ cÑ c˝ÑΔ!•˝ c
B cB cB cB cB cB˛ c"B cB cB cB cB c cÑΔ ÁΔ• c cÑ)J!Ñ cÑ-kRî=Ô%)JRJR%)5≠Ñ c c{B cB cB˙ c BÚ c BÓ c B¸ cB cB˛ c B cB cB cB cB cB cB cB cB cB cB cB cB cB cB c c˛Ñ c cB cB c˛B8 cB cB cB cB cB cB cB cB cB%)5≠9Œ9Œ=Ô=Ô-k!=ÔF11å•Ñ c cBÑΔ•B cÑΔ c cB cB cB cB cB cB cB c˛B c Á-kÑ•)J c c Á ÁÑB˝ c Δ c cÑÑB cB cB cB cB cB cB cB cB cB cB cB c˛B cB cB cB˚ cÑ cÑ•F1Ns9ŒΔJR^˜Rî1åÑ cÑ] cB cB c Ñ˙ c ÑÌ c B˛ c B˛ cB cB cB cB cB˛ c B cB cB cB cB cB cB˛ cB cB cB cB cB˛ cB cB cB cB cB˛ c Á˝9Œ=Ô-k5≠9Œ5≠ Á• c cB c•)JÑ cBÑ•ÑB cB cB cB cB˛ cB cB cB c cΔ!Ñ•%) c cÑ ÁÑÑ c cBΔ˛ c Ñ˝ cB cB cB˛ cB cB cB cB cB cB cB cB cB cB cB cB cB cB˝ c !JRNs-kΔF1Z÷g95≠ c cÑâ c cB cB¸ c B˛ c Bˆ c BÓ c B˛ c B˛ c B˛ cB cB cB cB cB cB cB cB cB cB c˛B c˛B cB cB cB cB cB cB cB cB cB cB cB cB c˛B cB cB cB c c Á˛5≠9Œ9Œ)J)J! Á!ΔÑ c cB• ÁÑ˛ c • c cB cB cB cB cB˛ cB cB cB cB cBΔ%)ÑB cÑÑ ÁÑBÑ c cB˛ c
B cB cB cB cB cB cB c˛B cB cB cB cB c˛B cB cB cB cB cB cB c1åJRF1)JÑBF1B! c cΔ\˛ c BÒ c ш c Ñ· c*B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB˛ c B˛ c B˛ c B cΔ5≠5≠9Œ5≠=Ô Á Á!%))J%)ÑÑB c c•• c cÑ• Á c cB˛ c B c cÑ•Δ c cB cB cB cB cÑ-kÑ cB c c-k Á c c)JΔ˛ c B˛ cB c c Á˝ cB cB cB˛ c B˛ c B cB cB cB cB cB cB cB cB c cJRBJR%)Ñ=ÔNs-k• cÑΔB cB cB˙ c B˛ c B¯ c B c B˛ c B¸ cB cB˛ c B˛ c B cB cB cB cB cB c˛B cB cB c˛B cB cB c˛B c˛B cB cB c˛B+ cB cB cB cB cB cB cBΔ1å9Œ5≠9Œ1åÑ Á%)%)-k%)Ñ c cB cΔ ÁÑ c c ÁΔÑB cB cB˝ cΔΔ cB c˛B c˛BÑ)JÑB˛ c%)%)B•9ŒÑ cÑ˝ c B cÑ%)• cB cB cB cB cB cB cB cB cB cB cB cB c˛B cB cB cB ÁNs9ŒJR%) c9ŒRî)JÑ c c%)V˛ c BÁ c Ñ˛ c Ñfl c B˛ c B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB˛ cB cB cB cB cB˛ c•5≠5≠9Œ5≠-k c Á˝!•Ñ˛ c)J!Δ cÑ Á1å Á˛ cDÑÑB cB c cÑ c cB cB cB cB cÑ-kÑ cB c cΔ! c%) ÁBÑ c cB cBÑ cΔ• cB cBÑ c cB cB cB cB cB cB cB cB cB cB cB˛ c B˛ c 1åNs)JNs! c5≠Z÷%)Ñ c•=ÔòB cB cB cB˛ cB cB cB cB cBÚ c B˛ c B˛ cB cB cB˛ c B˛ cB cB cB cB cB˛ c B cB cB cB cB cB c˛B cB cB cB cB c˛B c˛B˛ cB cB cB cB cB cB cB cB cB cB cBΔ1å˛9Œ ÁB•Δ Á%))J!ÑÑ c c%)=Ô5≠• c!9Œ-k˛ cÑ c cB cB cÑ c˛B c¸B c•ÑB c cÑ cÑ c ÁB¸ cB c cÑÑ˛ c Ñ˛ Á)B cB cB cB cB cB cB cB cB cB cB cB cB cB c cF1B ÁJR%)B5≠Vµ%)B c ÁJR,˛ c BÈ c Ñ” cB cB cB˛ c B cB cB cB cB cB cB˛ c B cB cB cB cB cB cB˛ c B¸ cΔ5≠5≠9Œ5≠•BÑΔ!%)1å!ΔΔÑÑ)JBB•Ñ•%)Δ cB˛ c B˙ cB cB cB cB cB˛ cBÑ˚ cBÑ˛ c •!-kΔ cÑ• cΔ!!Δ˛ c•• c cB˛ cB cB cB cB cB cB cB cB c cΔRî5≠ ÁVµ1å•-k)J˛ c1å9ŒñB cB cB˛ c B˛ cB cB cB cB cBˆ c B˙ cB cB cB˛ c B˛ cB cB cB˛ c B˙ c
B cB cB cB cB cB cB c¸B cB cB c˛B cB˛ c˛B c˛B4 cB cB cB cB cB cB cBΔ1å9Œ5≠-k c cB Á%)1åF1=Ô-k)J•Ñ•)J)J•B cÑ• c cB cB cB cB cB cB c˛B cB cB cB cB cB˛ c
B c c•• c c•!-k%) cBÑ˛ cÑ c cB cB cÑÑ c cB cB cB cB cB cB c˛B cB cB c!Z÷%)!Vµ9Œ)J1åÑ c c•=Ô-kH cBÚ c B˙ c BÊ c BÓ c B˛ c B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB˛ cB cB cB˛ c Á˛5≠*! cB c!5≠JRZ÷Ns-kΔÑ cÑ Á!• cBÑ•ÑB cB cB cB cB c cÑB cB cB cB cB˛ cB cÑÑ c cBΔΔ•Ñ c c••Ñ cÑ˛ c•Ñ˛Δ˘ cB cB cB cB cB cB cB cB cB c c5≠^˜ Á•-k5≠9Œ Á˛ c!B Á¡B cB¸ c B cB cB cB cB cB cB¸ c(B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB˛ c B cB cB cB cB cB c˛B c˛B cB cB c˛B cB cB c˛B8 cB cB cB cB cB cB cB c c%)5≠5≠1å ÁB cB)JBNsJR1å Á• c cBÑΔ•B cÑ• c cB cB cB cB c cÑB cB c˛B cB cÑ• cÑΔ Á˛ c5B!ΔB•B•ΔΔÑ ÁÑÑ•!)J-k)J-k! cBÑ c cB cB cB cB cB cB cB cB cB cB cB c=ÔRîÑÑ-k=Ô%)˛ cB-k Á ÁZÊ c B˛ c B˛ c B˛ cB cB¸ c B˛ cB cB cB˛ c B cB cB˛ cB cB cB cB cB cB cB cBÑÑ cB cB cB cB cB˛ c B˛ cB cBÑ)J9Œ5≠1å• cB c!B1å5≠)J!ÑÑ˛ c Á•ÑBÑ••B¸ cB cB˛ cB cB cB˝ c Á%)• c•Ñ cB cB! Á cÑ•)J5≠!1å%)ÑÑ Á!%)%) ÁΔÑ˛ c Ѹ c •˝ cB cB cB cB cB cB c c%)! c-kNs-kÑ˛ cÑΔÑ ÁºB cB cB˛ cB cB cB˛ c,B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB˛ c B˛ cB cB cB cB cB cB cB cB c˛B cB cB c˛B cB˛ c˛B cB cB cB cB c˛B cB cB cÑ-k5≠5≠)J cB cB•)J)J%)!ΔÑ c cBÑΔ%)˛ c •• cB cB cB cB cB˛ c B cB cB cB cÑ• c cB cB cBBΔ ÁB cÑΔ Á)J9ŒÑBÑÑ˝Δ•ÑÑ˛ c Ñ Á%) c cΔÑB cB cB cB cB cB cB cB cB c!Vµ1åÑB cB˝ c Ñu cBÍ c B˛ c B cB cB cB cB cB cB cB cB cB cB cB cB cB cB˛ c Bˆ c B˛ cB cB cB cB cB cB cB cB cB cB cB˛ cB cB cB cB cB˛ c B˛ cB cB•-k5≠5≠%)B cB cÑ)J!)J%)%)Ñ•˛ c
Á Á• c cÑ• c cB cB cB˛ cΔ!ÑÑ˝ cB cB c cÑ˛ c#••ÑBÑΔ c cÑ••5≠ Á cÑΔ! Á!!%)!%)ΔÑ cÑ•Ñ c cB•Δ cB˙ c B˛ cB cB cB9ŒB•˙ cÑBµB cB cB cB˛ c B˛ cB cB cB˛ c B˛ cB cB cB cB cB cB cB cB cB cB c˛B$ cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c˛B c˛B c˛B c cÑB cB cB c˛B c˛B" cB cB cBB•1å5≠5≠Δ cB cB c Á!Δ%))JΔÑÑB c cΔ• cBÑ ÁΔ˚ cBÑ cΔ•˛ c B cB cB c c!!Ñ cÑÑΔÑ cBÑB cÑ Á!)J cÑ Á)J)J-k)J¸-kÑ cÑ c˛B cBΔ• cB cB cB cB cB cB cB cB c cÑB cB cÑ•˛ c B{ cB cBˆ c Bˆ c B˛ c B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cBˆ c B˛ c B cB cB cB cB cB cB cB cB cBÑ c cB cB cB cB˛ c B˛ cB cB cBΔ1å5≠1åÑB cB cBΔ%)%))J)J Á•˛ c •)J)J•Ñ•5≠5≠Ñ c˛Ñ
B cB c cÑ c cB cB˛ c BÑ Á!Ñ c cѕѸ c Á-k-kΔ•-kBF1JR˚F1=Ô! cÑ c cB˝ c •˚ c B cB cB cB cB cB cB˛ cB!•˛ c BµB cB cB˙ c B˛ c B˛ c B˛ cB cB cB˛ c B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB˛ cB cB cB cB cB cB cB cB c˛B c˛B cB cB c˛B c˛B
cB cB cB cB cB c˛B cB cΔ5≠5≠-kB cB cBBΔ-k-k)J! Á˛Ñ3•%)F1JR%) cΔ%)! c cB cB cB cB cÑÑ c cB cB cB cB c cÑB cÑ Á• cB cBÑ-kNs)JÑ ÁBNsNsJR˛Ns JR˛F1"-k c c ÁÑ cB cB cB cB cB cB cB cB cB cB cB cB cB cB c•˝ c Bo cB cB cBÓ c B˝ c ј cB cB cB cB cB cB cB cB cB cB cB cBÙ cB cB cB˛ cB cB cB cB cB cB cBÑ c cB cB cB cB˛ c&B cB cB cB cB!5≠5≠ Á cB cB cB•%)%)Δ%)5≠-k!!•Δ)J-k• c cÑÑ cB˛ c B˛ c•!ΔÑ c cB cB cB c c•Δ cBÑ Á)JΔ˛ c
•-kNs! c%)JRRîNsRîJRNsJRNs˛JR=ÔÑ c Á1å%)Ñ˘ c B˛ c B˛ c B˛ c B˛ cB c c5≠Ñ˛ c BªB c˛B cB˙ cB cB cB˛ c;B cB cB cB cÑ cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c˛B c˛B cB cB c˛B cB˛ cB cB cB cB c˛B c˛B' cB c%)9Œ1å•B cB cB c c Á!5≠RîZ÷1åΔÑ cBÑ•Δ c cΔ%)Δ cBÑÑ cB c c˛ÑB cB cB cB cB cΔ!ÑÑ c-kB)J˛ cΔ%)F1Δ c)J˛RîNsNsJR˛Ns)JRNsBΔB Á-k5≠ Á cB cB cB cB cB cB cB cB cB cB cB cB cB cΔÑB c cBa cB cBÍ cB cÑ•Ñ cB¯ c B˛ c B˛ c B˛ c B˛ c B˛ c B˛ c Bˆ cB cB cB cB cB cB cB cB cB cB˛ cB cB cB˛ cB cB˛ c B˝ c 1å5≠-k c cB cB cB c ÁBVµRî9Œ!•Ñ cÑ•5≠1å• cΔ-k!˚ cB cB˛ cB cB cB cB c c Á-k)J•Ñ!BB• cÑ Á%)9Œ•Ñ1åNs˛VµRîRîNsRîNsRîNsJR! c•Δ%)5≠Ñ˛ cB c c•B cB˛ c B˛ c B˛ cB cB˚ cÑBöB cB cBÑ c cBˆ c B˛ cB cB cB cÑÑB˛ c B˛ c'B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c˛B c˛B c˛B cB cB c˛B c¸B cB cB cB c˛B cB cBΔ1å5≠! c˛B cB cB)JF19Œ˛%)!!ΔÑ•1å5≠• cÑ!Δ cB cB cB cB c cÑ c cB cB˝ cÑ%)5≠5≠ ÁÑ ÁBF1 ÁÑÑ ÁΔ%) c Á=Ô¸VµNsRî˝NsJR%)BÑB•-k)J c cB cB c• cB cB˛ c B cB cB cB cB cB cB¸ cU cB cB cΔÑ˛ c ÑÛ c B¸ c BÏ c B˙ c B˛ c Bˆ c B cB cB cB cB cB cB cB cB cB cB cB cB cB cB˛ c B˛ c/B cB cB c!5≠5≠ Á c cB cB cB c!-k!1åBF1)J%)•Ñ c Á!Ñ c cÑ• c cB cB cB c cѕѸ c.•ÑÑ c Á-k=Ô!Ñ ÁF1JR5≠••Δ!!Ñ!F1VµVµZ÷Z÷VµRîNsRîNsRîNsRîΔ c• c c Á=Ô Á c cB c c•˘ c B˛ c B˛ c B˙ c Δ∑B cB c c Á˘ c B˛ c B˛ cB cB cB cB cB cB cB cB cB˛ cB cB cB cB cB˛ c#B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c˛B c˛B cB cB c˛B cB cB cB cB cB cB c c%)1å1åÑ cB c˛B cB•Δ5≠JRNsB!ÑÑ c cÑ ÁΔ cB• ÁÑB˛ c#B cB c c Á!•ÑÑ c•Ñ• c cÑ-k=Ô)J•Δ5≠NsBΔÑΔ Á%)!%)BZ÷VµZ÷˛Vµ˛Rî˛Ns&•BΔ!• c1å1åÑ c cB cÑÑB cB cB cB cB cB cB cB cB cB cB c• c>˛ cB ÁÑÑ cÑ˛ c Ñ” c B˙ c B˛ c B˙ cB cB cB cB cB cB cB cB cB cB cB cB cB˛ c*B cB cB cB cB c cÑ%)1å-kÑB cB cB cB c c)J=Ô=Ô1å%)Δ••Ñ c•%)%)Ñ c•!Ñ˚ c ÑÑ Á1å5≠Δ• cÑ cÑ•Ñ cÑ-kB5≠ Á•%)F1JR!•Δ Á!-kJRVµVµ˛Z÷VµVµRîVµRîRîNsNsÑ cΔ)J1å!ΔB ÁÑ˛ cÑ•ÑB˙ c Bı cÑBßB cB c!ј c B cB cB cB cB cB cB˛ cB cB cB˛ cB cB cB cB cB˛ cB cB cB cB cB cB cB cB cB cB cB cB cB cB c˛B c˛B c˛B c˛B cB cB c˛B cB cB cB cB c˛B cB c c%)-k%)B c˛B cB cB c%)-k!%)!%) ÁΔ c cÑ%))JÑ c%)9Œ Á cÑ cÑ˛ c Ñ•-k1å Á•ÑB c cÑÑ c c Á9ŒBΔΔ ÁBRî9Œ•ΔΔ%)%)Ns¸Vµ Z÷˝Vµ NsRîNs• c Á-k5≠5≠-k5≠5≠ c cB c cΔ%)BB cB cB cB cB cB cB˛ c B˝ c Bc cB cÑ ÁÑÑ˛ c ÑÛ c B‚ c B˙ cB cB cB cB cB˛ cB cB cB cB cB cB cB cB cB cB cB cB cB˛ cB cB˛ cB cB˛ cEBÑ!1åΔ cB cB cB cB cBΔ!%)-k5≠1å! ÁΔ• Á9ŒBΔÑΔ9Œ!Ñ cÑ•Ñ c cÑ•)J9Œ%)ΔÑ c cÑ•Δ•• c5≠B1å•Δ5≠Rî=Ô!•!%)-kJRZ÷˛^˜cZ÷VµRîNsF1F1BF1ΔÑ%)=Ô9Œ5≠-k1åF1 Á˝ cÑÑ c cB˛ c B˛ c B˛ c B˚ cÑBù c•ΔΔ•!ı c B˛ c B˛ c B¯ c
B cB cB cB cB cB˛ c B˛ cB cB cB cB c˛B c˛B cB cB cB cB cB cB c˛B c˛B cB cB cB cB c˛B cB cB cB cB c˛B c˛B cÑ!-kÑ˛B c˛B cB c c!)J5≠BNs1å)J ÁΔ Á5≠B ÁÑ Á9Œ)J˛Ñ •˛ cPÑ•5≠9Œ-k•• cÑÑ•Δ•Ñ c9ŒB5≠Δ•1åJRNs!Δ Á1å1åNs^˜cRîJR5≠-k)J!Δ ÁΔ ÁΔ• cÑ Á!%)-k1å9Œ1å cB cB cB cB cB cB cB cB cB cB cB cB cB c cBK%)ΔÑÑ Á! Á¸ c Ñ◊ c,B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB˛ cB cB cB˛ c B˛ c"B cB•%))JB cB cB cB cB cB c!5≠JR^˜^˜B-k%)•Δ1åF1%)Δ•9Œ5≠˙Ñ• Á5≠B-kΔ•˛Ñ#•ΔΔÑ•)J=ÔF1%)Δ!NsNs9Œ Á-k5≠-k9Œ=Ô-k ÁΔ!!%)!%)!%)!! Á ÁΔ•˛Ñ Á1å5≠! cB˛ c BÏ c BùÑÑ c•Δ Á ÁÑı cB cB cB cB cB˛ c B˛ c B˛ cB cB cB˛ c B cB cB cB cB cB c˛B c˛B cB cB cB cB cB cB c˛B c˛B c˛B cB cB c˛B cB cB c˛B cB cB cB cB cB c•)JΔBB c˛B= cB cB cB!F1Z÷^˜cB5≠%) Á•5≠Ns5≠Ñ•5≠=Ô•ÑÑ•Ñ c cÑ•-k=Ô=Ô ÁΔÑ cÑ• ÁΔ• c!BRî9Œ%)%)RîZ÷Ns)J%)%)!ÑÑΔ!˝)J!%)!%)!! Á! ÁΔ••ÑÑ c!)J)JÑ cB cB cB cB cB cB cB cB˜ c BiÑ•Δ Á ÁΔ!• c cÑ cÑ cј c BÊ c B cB cB cB cB cB cB˛ cB cB cB˛ c B cB cB cB cB cB cB˛ cB cB cB˛ cB cB cB˛ cB cB cB˝ c$ Á)JÑB cB cB cB cB cB c ÁNsVµccNs-k-k!•!JR9Œ•Ñ5≠B! cÑÑΔ˛ c• Á=ÔF1-k ÁΔÑÑ• ÁΔ••%)JRZ÷JR1å)JNsVµ=ÔÑ c cÑ•˝)J-k)J-k%))J%)%)!!%)!Δ ÁΔ••ÑÑ• Á!• cB˛ c B˘ c ј c Bô!%) Á ÁΔ Á•ΔÛ cB cB cB cB cB˛ cB cB cB˛ c B˛ c#B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c˛B c˛B cB cB c˛B cB cB c˛B cB cB c˛B cB cBÑ Á%)B c˛B c˛B7 cB cBΔBVµ^˜g9Ns-k)J Á•!BBΔÑ-kJR-k•Ñ••ÑÑ c c•9ŒNs1å!Δ! c• Á%) Á Á)JJRZ÷Vµ-k ÁΔ• c cÑΔ Á˝%)-k%)˛-k )J%)%))J%)%)!%) ÁΔ•Δ¸Ñ •• cB cB cB cB cB˙ c B˛ cB c cBc ÁΔ!Δ Á••ΔÑ cÑ cÑ˛ c Ñfl cB cB cB cB cB˛ c B˛ c B˛ c B˛ c B˛ cB cB cB cB cB cB cB cB cB cB cB cB cB˛ c+B cB cB cB cB c•%) Á cB cB cB cB cB cB cÑ9ŒRî^˜c^˜9Œ1å ÁΔ!JRNs)JÑ%)JR=Ô˛• Á•˛Ñ•)JB5≠!! Á ÁΔ%))J)J Á ÁBVµ=ÔΔ c cB cÑΔ Á!!%)˛)J-k)J-k)J-k)J˛-k)J-k%)˛! Á Á•Δ˛Ñ•Ñ cB˘ c Ñı c Bì Δ˛ Á•ÑÑ• c cBÙ c B˛ c B˛ cB cB cB˛ c B˙ c#B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c˛B c˛B c˛B cB c¸B cB cB cB cB cB cB c c Á%)Δ˛B c˛B' cB cB cB c)JJRVµc^˜=Ô1å%)ΔΔBVµ-k•ΔBNs!ÑÑΔ• c•Δ!!F1B%)! Á%)˛)J-k!˛Δ ÑB cB c c••Δ Á!!˛)J%))J%))J)J-k)J-k)J)J-k)J%)%)!! Á ÁΔΔ••˛Ñ cB cB cB cB¸ cB cB cB˝ c Bb! Á ÁΔ• c•ÑÑ˛ cÑ cÑ cÑ cÑ„ c B˛ c B˛ c B˛ c B˛ c B˛ c B˛ c B˛ c B˛ cpB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB•!-kÑ cB cB cB cB cB cB cB!JRZ÷cg9B1å%) ÁÑBVµ9Œ! Á=ÔVµ9Œ••Δ ÁΔΔ• Á%)=ÔNs9Œ-k)J!%)%) ÁΔÑ cB cB cB c cÑÑ•• Á Á!!%)%)-k)J)J%)˛1å˝-k)J)J%))J˝! ÁΔΔ˛•ÑÑÌ c Bä!Δ••˝Ñ c cBˆ c B˛ c B˙ c B˛ c B˛ c'B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c˛B c˛B c˛B c˛B c˛B cB cB c˛B cB cB cB cΔ)J%) cB c˛B c˛B cB cB c!RîZ÷g9g9Ns1å-k••1åNsNs1å!1åVµNs%)%)!!˝ Á!1åJRB%) Á•Ñ c cB cB cB cB c˛Ñ•Ñ••ΔΔ Á!˛%))J%)˝-k)J-k-k)J%)˛)J˝! Á Á˝Δ˛Ñ cB cB c cÑ c cB cB cB cB˛ c[ ÁÑ•˝Ñ cÑ˙ c Ñ˛ c Ñ„ c B˙ c B˛ c B˛ c B˛ c B˛ c B˛ c B cB cB cB cB cB cB cB cB cB cB cB cB cB cB˛ c,B cB cÑ!-k!B cB cB cB cB cB cB cB)JNs^˜ccZ÷=Ô9Œ1å!%)B^˜F1)J%)NsZ÷F1%)!Δ˛• Ñ••!ΔÑ c cB cB cB˝ c Ñ•Δ•Δ••Ñ••ΔΔ˛!%))J%)%)-k1å˝-k )J˛-k )J˛%) !%)!! Á ÁΔΔ••ÑÑ˛ c ш cÑBk˝Ñ cÑ˝ c B c B˙ c B˙ c B˛ c#B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c˛B c˛B cB cB cB cB cB cB c˛B cB cB cBB c Á%)1å• c˛B c˛B c˛B cB c•F1Vµ˛c
F1JR9Œ-k)J=ÔZ÷Vµ)J!)J5≠)JÑ˚ cB cB c˛B cB cB cB c c••˛Δ˝•Ñ••ΔΔ˝ Á!!˝)J-k)J˛-k %)˛)J!%)!!%)! Á!ΔΔ••Ñ•Ñ¸ cB cB cB˝ c BRÑ c˛Ñ cÑ˝ cB c cÑ cÑ cÑ˛ cÑ cѯ c ÑÔ c B˙ c B˙ c B˛ c B˙ cB cB cB cB cB cB cB cB cB cB˛ c/B cB cB cB cB c c•!-k-kÑB cB cB cB cB cB cB cB c5≠VµckZg9Z÷BF11å5≠1åNsF1%) cÑ˛ c˛Ñ cÑ c cB cB cB cB cB˛ cÑΔΔ¸ Á˝Δ•Δ•ΔΔ˛ Á˛!%))J1å˛-k 1å˝-k
%))J)J!!)J)J%)!!Δ ÁΔΔ˛• Ñı c B}˝Ñ cÑ c cB cB cB‰ c3B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c˛B cB cB cB cB cB cB cB cBÑ•%)1å)J˛B c˛B c˛B cB cB cB ÁJR^˜cg9c=Ô1å!Δ••Ñ¸ c Ñ• Á!! Á Á• cB˛ c B cB cB c cÑ•Δ Á!˛ ÁΔ•˝Δ••˛Δ Á ÁΔΔ!-k˛)J-k-k)J-k-k˝)J Á!%)%)!%)!%) Á ÁΔΔ˛•Ñ c cB cB˛ c B˛ cbΔÑÑ cÑ˚ c B˝ cÑ cÑ cÑ˛ c Ñ˛ cÑ cÑ cÑÔ c B˙ c B˛ c B˛ c B˙ c B˛ cB cB cB cB cB cB cB cB cB cB¸ c'B cB cB cB cB cÑ!)J5≠Δ cB cB cB cB cB cB cB cB c c=ÔZ÷g9cVµ!•˛ cÑ cÑ cÑ• Á%)-k9ŒBB=Ô5≠-kÑ c cΔ c cB˝ cÑÑ••ΔΔ˝ ÁΔΔ ÁΔΔ•˘Δ Á%)˝)J-k-k1å)J˛-k)J!!%)˛! %)%)! Á ÁΔ••Δ•˛Ñ˙ cÑ ck ÁΔѸ c B˛ cB cBË c'B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c˛B cB cB cB cB c˛B cB cB cB cB cB cB cB cB c cΔ!-k1åÑB c˛B c˛B c˛B c˛B c%)RîJR)JÑ˚ cÑÑΔ Á)J-k5≠BJRNsRîRîF19Œ!ÑÑΔÑ c cB˛ cB c cÑÑ••Δ•˛Δ˝•Δ ÁΔ Á˛Δ ÁΔ!¸%)-k)J˛-k )J%)!%)!!Δ!!%)˝ Á˝•˛Ñ•ÑÑ˚ cÉ ÁΔ• cÑ cÑ c cB˛ c B˝ c Ñ˛ cÑ cÑ cÑ˛ c ÑÛ c B˛ c B˛ c Bˆ c B˛ c B˛ cB cB cB cB cB cB cB cB cB cB cB cB cB˛ cB cB cB˛ c B c c• Á)J1å)J c cB cB cB cB cB cB cB cB cBΔ1å Á˛ cÑ cÑÑΔ Á%))J5≠=ÔJRJRVµVµZ÷VµZ÷NsB)JΔÑ%)ÑΔÑ cB˚ cÑ c••¸ΔÑ••ΔΔ Á˛Δ ÁΔ ÁΔ%)%)!!)J)J-k-k1å-k-k%)-k)J%)!˝%) !˝ Á•ΔΔ•Ñ•ÑΔ••ÑÑ cÑ cÇ Á Á•Ñ cÑ˝ c B˛ c B cB cB˛ c-B cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c˛B cB c˛B c˛B c˛B cB cB cB cB cBÑΔ%))J5≠ Á c˛B c˛B c˛B c˛B/ cB c c•ÑÑ cÑÑΔ Á%)-k5≠9ŒBF1RîRîVµVµZ÷Z÷^˜Z÷RîB1å••%)ΔΔ•B cB cB cB cB c cÑÑ˝•ÑÑ˝•˚Δ Á Á%)!˝%)˛)J-k1å-k˛)J%))J)J˛%)! Á! Á˛Δ•Δ˝• ÁΔ˛•û ! ÁΔ•Ñ cÑ cÑ c cB˛ c B˝ cÑ cÑ cÑÛ c B˛ c B˛ cB cB cB cB cB˛ c B˛ c B˛ c B˛ cOB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB c cÑ•!)J1å1åΔB cB cB cB cB cB cB cB cB cB c cÑ•Δ Á%))J1å9ŒF1F1JRJRNs˛RîNsVµVµNsNsF1B5≠ ÁΔ)JΔ ÁΔ cB cB cB cB˝ c˝Ñ•Ñ•Ñ˛•Δ ÁΔ ÁΔ ÁΔ Á%))J!%)!%)!)J-k1å-k)J-k1å-k-k˛)J˛%)
ÑÑ ÁBVµF1!••ÑÑ˚ c B˛ c B˝ c˝Ñ •Ñ•ÑÑ cÑ cÑ c˝Ñ•ÑΔ• Á Á%)1åe˝ cB cB cB cB cB cB cB cB˛ cB cB cB˙ cB cBÏ c B¸ c B˛ c B˙ c B˛ c B˛ cB cB cB cB cB cB cB cB cBB)J5≠˛1å5≠1å1å5≠ ÁB cB c˛B c˛B cB cB cB cB cB cB cB cB c˛B
cB cB cBB Á• c••Δ•˛ΔÑΔ%))J%)˛)J%))J%)ÑB˝ c˛Ñ˛ c ÑÑ!ΔÑΔ1åkZg9Z÷9ŒΔ˛•ÑÑB˛ cB cB cB cB cB cB c cÑ c˙Ñ cÑ˛ c˝ÑΔΔ-k ÑÒ c B˙ c BÌ c Ñ◊ c B˛ c B cB cB cB cÑ1å5≠5≠1å¸5≠,Ñ cB cB cB cB cB cB cB c cÑB cB cB cB cB cB cB cB cB cB cB! Á•Δ Á Á˛! ÁΔΔ!˛)J -k˛)J-kÑ c cÑÑ˛•ÑÑ cÑÑ•˝ Á !JRo{o{c1å%)Δ••ÑÑ˝ c B˛ c B˛ c B˛ c B˝ c˝Ñ•ÑÑ c˚Ñ•%)z˚ c B˛ c B˙ c B cB cB cB cB cB cB˛ c B˛ c BÚ c B˛ cB cB¸ cB cB cB¯ c!B cB cB cB cB cB cB cB cB cB cBΔ1å5≠1å5≠1å5≠5≠9Œ)J cB c˛B cB cB cB cB c˛B cB cB cB cB cB cB c˛B cB cB cÑ! Á%)%))J)J-k)J%) Á! Á˘)JΔB c cÑÑ••Ñ cÑ cÑ•Δ)J5≠Δ)J%)g9kZkZ9Œ)J Á˛• ÑÑ cÑ c cB cB cB cB cB cB cB cB cB cB c cÑ c¸Ñ cÑ c)J Ñ cÑ cÑ˙ c Ñ˛ cÑ c cB cBÏ c BÌ c ÑÁ cB cB cB˛ cB c%)˚5≠9Œ5≠!˝ c B˛ c B cB cB cB cB cB cB˛ c B cB cB cB cB cB cB˛ c Á-k1å˝5≠9Œ1å)J%)!%)˚)J-k! c cÑÑ••Δ˛Ñ c cÑ cΔ ÁÑ-k=ÔRîkZB%) Á!ΔΔ ÁΔÑ•ÑÑ cѸ c Ñ˘ cB cB˛ cB c cÑ c˝Ñ•)Jì cÑ cÑÛ c
B cB cB cB cB cB˛ cB cB cB cB cB cB cB cB cB cB cB˙ c Bˆ c B˛ c B˛ cB cB cB cB cB cB cB cB cB cB c c-k1å5≠1å5≠1å˛5≠*• cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cB cBÑ)J˝=Ô&B=Ô9Œ1å)J!%)%))J)J-k%))J)J-k c cÑ•Ñ•ÑÑ cÑ ÁΔÑ cB-k)J5≠1å5≠)J Á!!˝ Á ••ÑÑ cÑ cÑ••˛ cÑ c cB cB cB cB cB cB cB cB˝ cÑÑ-k9˛Ñ cÑ cÑ cÑ cÑ˛ c Ñ c cB cB cB cB cBÍ c B˘ cÑ c cB‚ c B˛ cB c c•1å˚5≠9Œ-k• c cB cB cB cB cB cB cB cB cB˛ c B˛ cB cB cB cB cB˛ cB c cÑ%)=ÔB˛F1B9Œ-k-k!)J)J-k˛)J-k)J• cÑÑ Á Á• Á)J1å1å ÁΔÑÑ•!1å1å-k! Á!!˛ Á ΔΔ•Δ ÁΔÑΔ Á•˛Ñ˛•ÑÑ cÑ˚ c B˛ c B˙ c %)
d
° d ONLN d /ñ ¢ l (æ 0
MIKE REED AND ° d ONLN d =¢ Æ \ *
KONSTANTIN ° d ONLN d G¢ \Æ _ )J ° d ONLN d H¢ ^Æ g )O ° d ONLN d I¢ gÆ n ) T ° d ONLN d J¢ nÆ v )H ° d ONLN d K¢ vÆ )M ° d ONLN d L¢ Æ á ) E ° d ONLN d M¢ áÆ è )R , Palatino
° d ONLN d¿ ˙ ñ * PQuickDraw is a heck of a fine drawing engine for the Macintosh, but it does have ° d ONLN d ñ * Uits limitations. In particular, it supports a limited set of geometric primitives for ° d ONLN dg ñ * Udrawing: lines, rectangles, rounded-corner rectangles, ovals, arcs, and polygons (see ° d ONLN dΩ ñ*Ì * LFigure 1). If you want your application to provide the capability of drawing ° d ONLN d
* ñ6∏ * Econtours consisting of curves and straight lines, you’re out of luck. ° d ONLN dPB ñNˇ *SSure, you can use the arc primitive to draw a curve, but if you want to connect the ° d ONLN d§N ñZ * Rcurve to anything, you’ve got a problem. An arc represents a segment of an ellipse ° d ONLN d˜Z ñfˇ * Rand is specified by a bounding rectangle (defining the ellipse) and start and stop ° d ONLN dJf ñr * Uangles (see Figure 2). Because an arc is not specified by starting and ending points, ° d ONLN d†r ñ~ * Mit’s hard to know the exact points where QuickDraw will begin and end drawing ° d ONLN dÓ~ ñäÒ * Pthe arc. Thus, the arc does not lend itself to being combined with other arcs or ° d ONLN d?ä ññ Ø * lines. ° d ONLN dG¢ ñƉ *KA more useful curve primitive would be one that describes its start and end ° d ONLN dìÆ ñ∫ * Tpositions as points. The quadratic Bézier is just such a curve. Applications such as ° d ONLN dË∫ ñΔ √ * MacDraw
° d ONLN dÔ∫ √¬ » (fl ·®
° d ONLN d∫ »Δ +H use this type of curve to allow the drawing of freehand curves, and the ° d ONLN d9Δ ñ“ (Ó ¥MMacintosh itself uses this type of curve in an internal procedure to describe ° d ONLN dá“ ñfi ‹ * TrueType fonts. ° d ONLN dòÍ ñˆˆ *LIn this article we give you the lowdown on the quadratic Bézier. We show the ° d ONLN dˆ ñ * Qcoding and the data structures used by programs like MacDraw to draw this kind of ° d ONLN d7 ñ * Ocurve, and we show how your application can interchange data about this kind of ° d ONLN dá ñƒ * >curve with MacDraw and with devices equipped with a PostScript
° d ONLN d≈ƒ… (3‚®
° d ONLN dΔ… +
interpreter. ° d ONLN d‘ ñ&˛ (B ¥NAnd since the quadratic Bézier happens to be the same curve that TrueType uses ° d ONLN d$& ñ2 * P(in combination with other shapes) to draw outline fonts, we show how to extract ° d ONLN du2 ñ>% * curve data from TrueType fonts. | 8|. , Times
(1
+
7
(è ± MIKE REED AND KONSTANTIN OTHMER )ûhave (õ ±$become such regular contributors to ){develop )
that they (ß ±8scarcely need introduction. Still, we’ve just discovered * 2something new about them: they dabble in doggerel. * Consider this sample: *-Late into the night, by the glow of a candle, *
2Two men are found working on mischief and scandal. (èr5Their mice are a-clicking, their keyboards in motion, * 2They’re working on something of mythic proportion. * &We move closer in, to get a good look, * 1And notice they’re writing a get-rich-quick book. * /We wonder what topic could hold their attention * 1And keep them from working on some new invention. * /Their title reveals what the work will envelop— *
(How to Get Rich: Just Write for develop. )à•
4„mÌ*
(Ú;0CURVES AHEAD: WORKING WITH CURVES IN QUICKDRAW
Ùˇ ˛Î À À À À À À À À À À À À À ò 6 Ä ¥Æ Ä ¥Æ ∂ Ä Í. À À À À À À ˛ Ô Ä @ˆ ˝ ˝ !˛ qêÒ ±∂„ÃĘ Æ; 3nf66‹yà˛ ˛ R`Ò S§”ˆ ™L§L î)JtöP˛ !˛ S–Ò z §fiĘ Ú™OßD Ù/C¥õ»˛ !˛ RÒ ¬Y§–@˜ ™L$L Ñ(K4ö˛ !˛ QêÒ ±ó£ÃĘ Í; 3Jd&2Ùyà˛
Á ÄÎ ˝
Ë Í `˝ À À À À À À À À À À À À À À À À À À À À À À À À À À À À À À À ¸ ¸ ~ÿ ˝ ˇˇ¿˛ ˇ¿Ÿ ˝ ˇˇ¯˛ ˇŸ ˛ ˛ˇ ˛˛ ˇ¯Ÿ ˛ ˝ˇÄ ˇ˛Ÿ ˛ ˝ˇ¿ ˛ˇŸ ˛ ˝ˇ ˛ˇŸ òÅÆ @Æ H H a’x ÉÄ ˛ ˇˇˇˇˇˇ ˇˇˇˇÃà ˇˇˇˇôô ˇˇˇˇff ˇˇˇˇ33 ˇˇˇˇ ˇˇÃÃˇˇ ˇˇÃÃÃà ˇˇÃÃôô ˇˇÃÃff
Å Û êˇÅ “ Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” òÅÆ Ä ¥Æ H H a’x ÖÄ ˛ ˇˇˇˇˇˇ ˇˇˇˇÃà ˇˇˇˇôô ˇˇˇˇff ˇˇˇˇ33 ˇˇˇˇ ˇˇÃÃˇˇ ˇˇÃÃÃà ˇˇÃÃôô ˇˇÃÃff
ˇ ˇˇ ˇ ˇ ˛ˇ˛ ˇ˝ ˇ ˛ˇ˛ ˇ˝ ˇ˛ˇ ˇ˛ ˇ ˇ ˛ˇ ˇ˛ˇˇ ˇË òÊ ˇ˛ ˇ ˇ ˇ ˇ¸ ˇÅ ˙ ˇ˛ ˇˇ˝ ˇ ˇ ˇˇ ˇˇ ˇ ˇ ˇˇ ˇ¸ ˇ§ ˇ˛ ˇ ˇ ˇ ˇ ˇ ˇ ˇ ˇˇ˝ ˇ ˇ˛ ˇ ˇˇ ˇˇ ˇ ˇ ˇ˝ ˇ˝ ˇ ˇ˝ ˇ ˇ ˇˇ ˇˇ ˇ ˇ ˇˇ ˇ˚ ˇÈ íÊ ¸ˇ ˇ ˇ˛ ˇˇ ˇÅ ˘ ˇ˛ ˇ ˇˇ˛ ˇˇ ˇ ˝ˇ ˇ˛ ˝ˇ ˇˇ ˇ£ ˇ˛ ˛ˇ ˛ˇ ˇ ˇ˛ ˛ˇ ˇˇ˛ ˛ˇ˝ ˇˇ ˇˇ ˇ ˇ ˇ ˇˇ ˇ˝ ˇ ˇˇ˛ ˇˇ ˇ ˝ˇ ˇ˛ ˝ˇ ˇˇ˛ ˇË Å ± ˇÅ « ˇfl Å ≥ ˇˇÅ » ˇˇfi Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” ÿ ˆˇ‘ ˚ˇÅ Å ∫ fi ͡fi ÙˇÅ Å Ω !‡ ¯ˇ1
! E! E! ÿ ! EÌ ! E! ” ͡ ˚ˇ ¸ˇ≈ q∏ 5ˇˇˇˇ« E E E€ E E Ó E E E ” flˇ˝ ˚ˇ ˝ˇ≈ h∏ 5ˇˇˇˇ√ E! ‹ E! Ó E! E— ’ˇ ¸ˇΔ b÷ ˚ˇÈ 5ˇˇˇˇ¿ E! Efl E! Ó E! – Àˇ ˝ˇΔ e⁄ ÛˇÌ 5ˇˇˇˇº E E ‚ E EÓ E E E – ¯ˇ –ˇ m‹ ÔˇÔ 5ˇˇˇˇ∏ E! „ EÓ E! EŒ ˘ˇ —ˇ’ s› Ìˇ 2ˇˇ˛ˇµ ! E ! Ó E! Õ ˘ˇ ˚ˇ —ˇ· Ñfl ˜ˇ ˜ˇÚ 4ˇˇˇˇ± E E Ô E E E Õ ¯ˇ ¸ˇ —ˇÌ òÅÆ @ ÄÆ H H a’x áÄ ˛ ˇˇˇˇˇˇ ˇˇˇˇÃà ˇˇˇˇôô ˇˇˇˇff ˇˇˇˇ33 ˇˇˇˇ ˇˇÃÃˇˇ ˇˇÃÃÃà ˇˇÃÃôô ˇˇÃÃff
† ˚ˇÅ Å ∫ Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” òÅÆ Ä ¥Æ H H a’t àÄ ˛ ˇˇˇˇˇˇ ˇˇˇˇÃà ˇˇˇˇôô ˇˇˇˇff ˇˇˇˇ33 ˇˇˇˇ ˇˇÃÃˇˇ ˇˇÃÃÃà ˇˇÃÃôô ˇˇÃÃff
ˇ ˇ ˇ˛ ˇ ˇ˛ ˇÅ ˇ˛ ˇ ˇ ˛ ˇá ˇ˛ ˇ ˇ ˇ ˇ ˇ˛ ˇ ˇ ˛ˇ ˇ˝ ˛À E√ ˝ˇ˛ ˇ ˛ˇ ˇ ˇÅ ˇ˛ ˇ˛ ˇˇ ˇÜ ˇ˝ ˇˇ ˇ ˇ ˛ˇ ˇˇ ˇ ˇ˛ ˇ Å Å ú ˇ˝ ˇæ Å Å ù ˇ˛ ˇ˛Ω Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” Å Å Å ” † è † É † ø
d , Helvetica
. ° d ONLN d h ñs æ (è ¥Figure 1 ° d ONLN d r ñ} *
QuickDraw’s Geometric Primitives
° d ONLN d *é ñúf * DRAWING CURVES AND PATHS , Palatino
° d ONLN d C† ñ¨ *RThe quadratic Bézier has a couple of properties that make it useful as a basis for ° d ONLN d ñ¨ ñ∏ˇ * Qdrawing curves in QuickDraw. First, it can be rotated easily by changing just the ° d ONLN d Ë∏ ñƒ * Sstarting, ending, and middle points and not the underlying equation itself. Second, ° d ONLN d<ƒ ñ–˛ * Qit can easily be subdivided into any number of shorter curves that become flatter ° d ONLN dé– ñ‹ˇ * Uand flatter, until in effect it can be drawn with a series of straight lines. Indeed, ° d ONLN d‰‹ ñË * Rthe basic technique for drawing a curve using the existing QuickDraw primitives is ° d ONLN d7Ë ñÙ˛ * Tby subdividing the curve into a series of line segments. If you’re interested in the ° d ONLN dåÙ ñ µ * <mathematics behind this, see “Parametric Equations, Anyone?” ° d ONLN d ñ˜ *LThis section begins by showing sample C code that implements the subdivision ° d ONLN d ñ$˘ * Malgorithm that produces a curve. We then move on to consider how to produce a x Bx/ , Times
190.4756 386.0974 202.2684 359.1874 202.2684 325.9933 c
202.2684 292.7992 190.4756 265.8892 175.9287 265.8892 c
161.3819 265.8892 149.589 292.7992 149.589 325.9933 c
149.589 359.1874 161.3819 386.0974 175.9287 386.0974 c
b
175.9287 325.9933 m
B
U
u
0 0.3 0 0 k
1.5 w
122.7859 386.3348 m
139.873 386.3348 153.7253 374.8611 153.7253 360.708 c
153.7253 346.5549 139.873 335.0812 122.7859 335.0812 c
105.6988 335.0812 91.8464 346.5549 91.8464 360.708 c
91.8464 374.8611 105.6988 386.3348 122.7859 386.3348 c
b
122.7859 360.708 m
B
U
u
0 0.1 0 0 k
4 w
121.9558 318.9662 m
113.6866 318.9662 106.9828 312.2625 106.9828 303.9933 c
106.9828 295.7241 113.6866 289.0203 121.9558 289.0203 c
130.225 289.0203 136.9287 295.7241 136.9287 303.9933 c
136.9287 312.2625 130.225 318.9662 121.9558 318.9662 c
b
121.9558 303.9933 m
B
U
0 1 0 0 K
347.9287 282.9933 m
347.9287 355.9933 235.9287 359.4933 v
S
2 w
330.4287 282.9933 m
330.9287 338.4933 235.9287 342.9933 v
S
1 w
312.9287 282.9933 m
311.9287 ° ¿
◊322.9933 236.9287 325.4933 v
S
u
0 O
0 0.1 0 0 k
0 G
490.5709 548.4933 m
497.1986 548.4933 502.5713 543.1206 502.5713 536.4935 C
502.5713 458.4931 L
502.5713 451.866 497.1986 446.4933 490.5709 446.4933 C
376.5718 446.4933 L
369.944 446.4933 364.5713 451.866 364.5713 458.4931 C
364.5713 536.4935 L
364.5713 543.1206 369.944 548.4933 376.5718 548.4933 C
490.5709 548.4933 L
b
433.5713 497.4933 m
B
U
u
0 0.2 0 0 k
2 w
472.429 530.4933 m
479.0563 530.4933 484.4287 525.1205 484.4287 518.4934 C
484.4287 476.4931 L
484.4287 469.8661 479.0563 464.4933 472.429 464.4933 C
394.7136 464.4933 L
388.0864 464.4933 382.714 469.8661 382.714 476.4931 C
382.714 518.4934 L
382.714 525.1205 388.0864 530.4933 394.7136 530.4933 C
472.429 530.4933 L
b
433.5713 497.4933 m
B
U
u
0 0.3 0 0 k
4 w
455.4286 512.4933 m
462.0558 512.4933 467.4287 507.1205 467.4287 500.4932 C
467.4287 494.4933 L
467.4287 487.8661 462.0558 482.4933 455.4286 482.4933 C
411.7141 482.4933 L
405.0869 482.4933 399.714 487.8661 399.714 494.4933 C
399.714 500.4932 L
399.714 507.1205 405.0869 512.4933 411.7141 512.4933 C
455.4286 512.4933 L
b
433.5713 497.4933 m
B
U
u
1 g
1 w
236.9287 313.4933 m
236.9287 367.9933 L
223.4287 367.9933 L
223.4287 313.4933 L
236.9287 313.4933 L
f
230.1787 340.7433 m
F
U
u
304.1787 271.2433 m
358.6787 271.2433 L
358.6787 284.7433 L
304.1787 284.7433 L
304.1787 271.2433 L
f
331.4287 277.9933 m
F
U
0 g
96.4287 516.2433 m
96.4287 511.4933 l
122.6787 459.9933 l
127.9287 459.9933 l
127.9287 465.7433 l
102.4287 516.2433 l
96.4287 516.2433 l
f
115.1787 529.7433 m
171.308 509.1465 l
173.2498 509.2498 l
173.1476 510.4901 l
117.0537 531.2433 l
115.3037 531.3683 l
115.1787 529.7433 l
f
0 To
1 0 0 1 102.4287 419.8505 0 Tp
TP
0 Tr
/_Helvetica 8 Tf
0 Ts
100 Tz
0 Tt
0 TA
0 0 5 TC
100 100 200 TW
0 0 0 Ti
0 Ta
0 Tq
9 0 Tl
0 Tc
0 Tw
(Lines) Tx
(\r) TX
TO
0 To
1 0 0 1 274.9287 419.8505 0 Tp
TP
-20.0049 0 Td
0 Tr
1 Ta
(Rectangles) Tx
(\r) TX
TO
0 To
1 0 0 1 433.5713 419.8505 0 Tp
TP
-48.4531 0 Td
0 Tr
(Rounded-corner rectangles) Tx
(\r) TX
TO
0 To
1 0 0 1 435.7144 240.8505 0 Tp
TP
-16.4502 0 Td
0 Tr
(Polygons) Tx
(\r) TX
TO
0 To
1 0 0 1 291.0537 240.8505 0 Tp
TP
-7.999 0 Td
0 Tr
(Arcs) Tx
(\r) TX
TO
0 To
1 0 0 1 147 240.8505 0 Tp
TP
-10.2227 0 Td
0 Tr
(Ovals) Tx
(\r) TX
TO
0 To
1 0 0 1 102.4287 419.8505 0 Tp
TP
0 Tr
0 Ta
(Lines) Tx
(\r) TX
TO
97.125 532.625 m
97.2627 529.4883 l
147.3675 479.4164 l
150.835 479.3345 l
150.7546 482.5295 l
100.787 532.4643 l
97.125 532.625 l
f
%%PageTrailer
gsave annotatepage grestore showpage
%%Trailer
Adobe_IllustratorA_AI3 /terminate get exec
Adobe_typography_AI3 /terminate get exec
Adobe_customcolor /terminate get exec
Adobe_cshow /terminate get exec
Adobe_cmykcolor /terminate get exec
Adobe_packedarray /terminate get exec
%%EOF
>† ◊# ˇ ˇˇˇˇ # ◊
6 6 —´ " 6 6 ° d
ONLN f H " —´ ° d
ONLN f `X † Ç † é
4 5 5 6 6 ò 0 @u @u 6 6 v´ — — — — — Ê Ôˇˇ Ê ¯ ˛˚ ˇ Ê ˜ ¿¸ ˇ Ê ˆ x¸ ˇ Ê ˆ ¸ ˇ Ê ˆ ‡˝ ˇ Ê ı 8˝ ˇ Ê ı ˝ ˇ Ê ı IJ ˇ Ê Ù ‡˛ ˇ Ê Ù 8˛ ˇ Ê Ù ˛ ˇ Ê Ù ˛ ˇ Ê Ù Ä ˇ
Ê Û ‡ ˇ Ê ¯ `˛ 0 ˇ Ê ¯ ‡˛ ˇ Ê ¯ IJ ˇ Ê ¯ IJ ˇ Ê ¯ IJ Ä ˇ Ê ¯ ¸ ¿ ˇ Ê Ú ` ˇ Ê Ú 0 ˇ Ê Ú ˇ Ê Ú ˇ Ê Ú ˇ Ê Ú ˇ Ê Ú ˇ Ê Ú Äˇ Ê Ò ¿ˇ Ê Ò @ˇ Ê Ò `ˇ Ê Ò 0ˇ Ê Ò ˇ Ê Ò ˇ Ê Ò ˇ Ê Ò ˇ Ê Ò ˇ Ê Ò ˇ Ê Ò ˇ Ê Ò ˇ Ê Ò Åˇ
Ê Åˇ
Ê ¡ˇ
Ê Aˇ
Ê aˇ
Ê !ˇ
Ê !ˇ
Ê 1ˇ
Ê ˇ @ Î ˇ
Î ˇ Ì ˇ pÎ ˇ Ä Î ˇ så Ì
ˇ ˚ Ì ˇ ˚ Ì ˇ
Ê ˇ ò 0 @ Äu @ Äu v 6 ∂´
Ê ˇ
Ê ˇ
Ê ˇ
Ê ˇ
Ê ˇ
Ê ˇ
Ê ˇ
Ê ˇ
Ê ˇ
Ê ˇ
Ê ˇ ! 8 ò Ä ˘ Û Ã ˇ $ B b¯ Û , ˇ " 9)Ä Ä˙ Û ˇ ! r)Ë Ä Ä §˘ Û ˇ ! )Ä Á Á˘ Û ˇ " q¥Δ0 ‡à c c Ä˙ Û ¿ ˇ ˘ Ä˙ ˇ ˙ Ä Ä˙ ˇ
˛êêê @ Äu v 6 ∂´ ' Å § ÎÅ Ú ˇˇÎ˚ Å § ÎÅ Ò ˇÎ˚ Å § ÏÅ Ò ˇÏ˚ Å § ÎÅ Ò ˇÎ˚ Å § ÎÅ Ò ˇÎ˚ Å § ÏÅ Ò ˇÏ˚ Å § ÎÅ Ò ˇÎ˚ Å § ÎÅ Ò ˇÎ˚ Å § ÏÅ Ò ˇÏ˚ Å § ÎÅ Ò ˇÎ˚ Å § ÎÅ Ò ˇˇ˚ GÏ ˛ˇ˚ ˇ˛ ˛ˇÓ ˇ ˇˇÔ ˇˇı ˇˇÙ ˇˇÎ ˇˇ˝ ˇ˘ ˇ∏ Ïã ˇˇ ˇˇ ˇˇ ˇ˚ OÌ ˇ ˇ˚ ˇ˛ ˇ ˇÏ ˇÔ ˇÒ ˇÙ ˇ˛ ˇ˝ ˇÛ ˇ˛ ˇˇ˛ ˇ≥ Îå
˛êêê Ä õu ∂ 6 —´ ' Å § ÎÅ Î˚ Å § ÏÅ Ï˚ Å § ÎÅ Î˚ Å § ÎÅ Î˚ Å § ÏÅ Ï˚ Å § ÎÅ Î˚ Å § ÎÅ Î˚ Å § ÏÅ Ï˚ Å § ÎÅ Î˚ Å § ÎÅ Î˚ Å § ÏÅ Ï˚ Å § ÎÅ Î˚ Å § ÎÅ Î˚ Å § ÏÅ Ï˚ Å § ÎÅ Î˚ Å § ÎÅ Î˚ Å § ÏÅ Ï˚ Å § ÎÅ Î˚ Å § ÎÅ Î˚ Å § ÏÅ Ï˚ Å § ÎÅ Î˚ òÅ § ˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î Ï˛Î˚ Å Å ã Å Å ã Å Å ã Å Å ã Å Å ã † è † É † ø
d , Helvetica
. ° d ONLN d Ω » @ +6‰Figure 2 ° d ONLN d « “ Æ *
$How an Arc Is Specified in QuickDraw , Palatino
° d ONLN d . fi Í9 *Bcombination of curves and straight lines, known in the lingo as a ° d ONLN d p fi9 ÍP (Wpath ° d ONLN d t fiP Íë ). Then we talk ° d ONLN d É Í ˆÖ ( 6Qabout how to combine paths to produce shapes. Note that for a curve, as for every ° d ONLN d ’ ˆ É * Mgeometric primitive in QuickDraw, you always have two options: you can either ° d ONLN d# â * Tframe it or fill it. We show you how to do the framing; you can do the filling using ° d ONLN dx £ * the call FillPoly or PaintPoly.
° d ONLN dò+ 6 w * FRAMING A CURVE
° d ONLN d®6 B| * MThe code that implements the subdivision algorithm to produce a curve takes a ° d ONLN dˆB NÉ * Qvalue for the number of times the curve should be subdivided before it’s drawn as ° d ONLN dHN ZÑ * Pstraight lines. This number can be dynamically computed based on the size of the ° d ONLN dôZ fá * Ocurve and the quality-versus-speed trade-off the application wants to make. The ° d ONLN dÈf rX * Gcode uses fixed-point coordinates to maintain high precision during the ° d ONLN d1r ~ S *
subdivisions. ° d ONLN d@ä ñs *PTo begin, let’s define a few macros to help us use fixed-point coordinates in an ° d ONLN dëñ ¢ § * integer-based graphics system. ,
Courier
° d ONLN d∞Ø ∫ Y *
#define FR(x) ° d ONLN d¬Ø ö∫ ˛ )Ç((x) + 0x8000 >> 16) ° d ONLN d◊ª Δ Y (‚ 6
#define ff(x) ° d ONLN dȪ öΔ Ô )Ç((long)(x) << 16) ° d ONLN d˚« “ | (Ó 6#define fmoveto(x,y) ° d ONLN d« ö“ ˛ )ÇMoveTo(FR(x), FR(y)) ° d ONLN d&” fi | (˙ 6#define flineto(x,y) ° d ONLN d<” öfi ˛ )ÇLineTo(FR(x), FR(y)) ° d ONLN dQfl Í h ( 6#define AVE(a,b) ° d ONLN defl öÍ Ô )Ç(((a) + (b)) / 2)
° d ONLN dwˆ % ( 6FR ° d ONLN dzˆ NU )69The same as FixRound: takes a Fixed and makes it a short. ° d ONLN d¥ (* 6ff ° d ONLN d∑ Nu )6BThe reverse of FixRound: takes a short and promotes it to a Fixed. ° d ONLN d˙ = (6 6fmoveto ° d ONLN d N. )60The same as MoveTo, but takes Fixed coordinates. ° d ONLN d3 & 7 (B 6flineto ° d ONLN d; N&) )60The same as LineTo, but takes Fixed coordinates. ° d ONLN dl& 2 . (N 6AVE ° d ONLN dp& N23 )63Averages two numbers, either Fixed, short, or long. v 4v& , Times
(y)
+
9
(è 6+For an explanation of the Fixed data type, )õsee (õ 6Inside Macintosh )9 Volume I, Chapters 3 and 16.• 4≈ 1· Ú
+ΔW0CURVES AHEAD: WORKING WITH CURVES IN QUICKDRAW
481.5281 508.7774 514.3503 476.4611 514.3503 436.433 c
S
0 To
1 0 0 1 447.5 488.433 0 Tp
TP
0 Tr
0 O
0 g
0 J 4 M
/_Helvetica 8 Tf
0 Ts
100 Tz
0 Tt
0 TA
0 0 5 TC
100 100 200 TW
0 0 0 Ti
0 Ta
0 Tq
9 0 Tl
0 Tc
0 Tw
(0\241) Tx
(\r) TX
TO
0 To
1 0 0 1 485.5 432.933 0 Tp
TP
0 Tr
(90\241) Tx
(\r) TX
TO
0 To
1 0 0 0.7225 152.4597 453.5816 0 Tp
TP
0 Tr
/_Courier 13.1487 Tf
61.4117 Tz
13.8408 0 Tl
({) Tx
(\r) TX
T*
(\r) TX
T*
(\r) TX
T*
(\r) TX
T*
(\r) TX
T*
(\r) TX
T*
(}) Tx
(\r) TX
TO
0 To
1 0 0 0.7225 165.4597 453.5816 0 Tp
TP
0 Tr
(Rect r;) Tx
(\r) TX
T*
(\r) TX
T*
(SetRect\(&r, 0, 0, 144, 144\);) Tx
(\r) TX
T*
(FrameArc\(&r, 0, 90\);) Tx
(\r) TX
T*
(PenPat\(gray\);) Tx
(\r) TX
T*
(FrameRect\(&r\);\312) Tx
(\r) TX
TO
%AI3_BeginCrops
userdict /AI3_noCropMarks known not {
u
u
0 R
0 G
0.5 w
112 342 m
85 342 L
S
121 333 m
121 306 L
S
U
u
112 529 m
85 529 L
S
121 538 m
121 565 L
S
U
u
545 529 m
572 529 L
S
536 538 m
536 565 L
S
U
u
545 342 m
572 342 L
S
536 333 m
536 306 L
S
U
U
} if
%AI3_EndCrops
%%PageTrailer
gsave annotatepage grestore showpage
%%Trailer
Adobe_IllustratorA_AI3 /terminate get exec
Adobe_typography_AI3 /terminate get exec
Adobe_customcolor /terminate get exec
Adobe_cshow /terminate get exec
Adobe_cmykcolor /terminate get exec
Adobe_packedarray /terminate get exec
%%EOF
( ◊# ˇ ˇˇˇˇ # ◊
d , Helvetica
. ° d ONLN d ! 0 /$ +NJ PARAMETRIC EQUATIONS, ANYONE? " 6 @ # 6 A 6, " 6- # " 7 @ " 7-
° d ONLN d < 0 G
*4Though you can draw curves without understanding the ° d ONLN d T H 0 S * 7mathematics behind the operation, some people find this ° d ONLN d å T 0 _ * 8kind of thing interesting. This explanation is for those ° d ONLN d ≈ ` 0 k Æ * people (you know who you are). ° d ONLN d ‰ w 0 Ç *6A quadratic Bézier (or parabola) can be defined by the ° d ONLN d Ç 0 ç Ä * parametric equation ° d ONLN d/ ô 0 § 3 *f ° d ONLN d0 ô 3 § 6 )( ° d ONLN d1 ô 6 § 9 )t ° d ONLN d2 ô : § = )) ° d ONLN d3 ô > § G ) = ° d ONLN d6 ô G § L ) a ° d ONLN d7 ô L § ] )(1 – ° d ONLN d< ô ] § ` )t ° d ONLN d= ô a § d ))
° d ONLN dS ∞ 0 ª J ( ◊ Nwhere ° d ONLN dY ∞ J ª M )t ° d ONLN dZ ∞ M ª ã ) is a scalar and ° d ONLN dk ∞ ã ª ü )>a, b, ° d ONLN dq ∞ ü ª ∞ )and ° d ONLN du ∞ ∞ ª µ )c ° d ONLN dv ∞ µ ª ‚ ) are points. ° d ONLN dÉ « 0 “ ( Ó N6This parametric formulation has the advantage of being ° d ONLN d∫ “ 0 › Æ * rotationally independent: since ° d ONLN d⁄ “ Æ › ± )~t ° d ONLN d€ “ ± › ˝ ) is the independent ° d ONLN dÔ › 0 Ë u ( Nvariable, and not ° d ONLN d › u Ë z )Ex ° d ONLN d › z Ë Ü ) or ° d ONLN d › Ü Ë ã ) y ° d ONLN d › ã Ë
)", there is no bias for curves that ° d ONLN d* Ë 0 Û ( N9are symmetric about the x- or y-axis. Thus, to rotate the ° d ONLN dd Û 0 ˛ ™ * curve, you only need to rotate ° d ONLN dÉ Û ™ ˛ æ )za, b, ° d ONLN dâ Û æ ˛ œ )and ° d ONLN dç Û œ ˛ ‘ )c ° d ONLN dé Û ‘ ˛ ) into their new ° d ONLN dû ˛ 0 ˇ (% N5positions, while the equation for the curve stays the ° d ONLN d‘ 0 I * same. ° d ONLN d⁄ 0+ ˇ *5To better understand the equation, take a look at its ° d ONLN d+ 06 * 7geometric representation in Figure 3. You’ll note there ° d ONLN dH6 0A √ * &that as the curve is drawn from point ° d ONLN dn6 √A » )ìa ° d ONLN do6 »A Í )
to point ° d ONLN dy6 ÍA Ô )"c ° d ONLN dz6 ÔA Ù ), ° d ONLN d|6 ÙA ˜ )t ° d ONLN d~A 0L Æ (h N!varies from 0 to 1. The curve at ° d ONLN düA ÆL ≥ )~a ° d ONLN d†A ≥L ) is tangential to the line ° d ONLN dªL 0W = (s Nab, ° d ONLN dæL =W Ç )
and the curve at ° d ONLN d–L ÇW á )Ec ° d ONLN d—L áW Â ) is tangential to the line ° d ONLN dÏL ÂW Ú )^bc. ° d ONLN dÔL ÚW ˇ )
Its ° d ONLN dÙW 0b ˜ (~ N0maximum displacement from the line that could be ° d ONLN d%b 0m ^ * drawn from ° d ONLN d0b ^m e ).a ° d ONLN d2b em o )to ° d ONLN d5b om t )
c ° d ONLN d6b tm ¬ ) is reached at point ° d ONLN dKb ¬m « )Nq ° d ONLN dLb «m Ê ), where ° d ONLN dTb Êm È ) t ° d ONLN dUb Èm ) is 0.5. In ° d ONLN dam 0x á (î Naddition, the curve at ° d ONLN dxm áx å )Wq ° d ONLN dym åx )# is parallel to the (imagined) line ° d ONLN dùx 0É : (ü Nac ° d ONLN düx :É = )
. ° d ONLN d°è 0ö (∂ N5Perhaps the most useful property of the curve in this ° d ONLN d◊ö 0• * 8form is the easy way it can be decomposed into a pair of ° d ONLN d• 0∞ * 5smaller curves, each of the same form. This is called ° d ONLN dF∞ 0ª ^ * subdivision ° d ONLN dQ∞ ^ª Ù ).' and is the basis for drawing curves in ° d ONLN dyª 0Δ _ (‚ N
QuickDraw. ° d ONLN dÖ“ 0› ‘ *(Suppose we subdivide the curve at point ° d ONLN d≠“ ‘› Ÿ )§q ° d ONLN dÆ“ Ÿ›
)
, as shown in ° d ONLN dº› 0Ë | ( NFigure 4. The point ° d ONLN d–› |Ë É )Lq ° d ONLN d“› ÉË ä )is ° d ONLN d’Ù 0ˇ 5 ( Nq ° d ONLN d÷Ù 5ˇ > ) = ° d ONLN dŸÙ >ˇ A ) f ° d ONLN d⁄Ù Bˇ E )( ° d ONLN d€Ù Fˇ b )0.5) = ( ° d ONLN d„Ù bˇ g ) a ° d ONLN d‰Ù gˇ u ) + 2 ° d ONLN dËÙ uˇ z )b ° d ONLN dÈÙ zˇ É ) + ° d ONLN dÏÙ Éˇ à ) c ° d ONLN dÌÙ àˇ ó )) / 4 ° d ONLN dÛ 0 (2 N;The tangent (that is, the first derivative) of the curve at ° d ONLN d/ 0! 5 * q ° d ONLN d0 5! à ) is parallel to the line ° d ONLN dI à! ï )Sac.
a ° d ONLN d¢ jê uô ) + ° d ONLN d• jô uû ) b ° d ONLN d¶ jû uπ ) ) / 2 to ° d ONLN dØ jπ uæ )q ° d ONLN d∞ jæ u… ) is
° d ONLN d¥ d… vÕ )
° d ONLN dµ jÕ uı )
tangential ° d ONLN d¿ u ÄZ ( ú<to the curve at ° d ONLN d– uZ Ä_ )<q ° d ONLN d— u_ Äb ). ° d ONLN d‘ å ó# ( ≥<q ° d ONLN d’ å# ó, ) – ° d ONLN dÿ å, ó5 ) b' ° d ONLN d€ å5 ó: ) = ° d ONLN d› £ Æ! ( <( ° d ONLN dfi £! Æ( )a ° d ONLN d‡ £( Æ4 )+ 2 ° d ONLN d„ £4 Æ; ) b ° d ONLN d £; ÆB )+ ° d ONLN dÁ £B ÆG )c ° d ONLN dË £G Æb ) ) / 4 – ( ° d ONLN dÒ £b Æg )a ° d ONLN dÚ £g Æp ) + ° d ONLN dı £p Æu ) b ° d ONLN dˆ £u Æã )) / 2 = ° d ONLN d˛ ∫ ≈! ( ·<( ° d ONLN dˇ ∫! ≈& )a ° d ONLN d ∫& ≈4 ) + 2 ° d ONLN d ∫4 ≈9 )b ° d ONLN d ∫9 ≈B ) + ° d ONLN d ∫B ≈G ) c ° d ONLN d ∫G ≈U ) – 2 ° d ONLN d
∫U ≈Z )a ° d ONLN d ∫Z ≈h ) – 2 ° d ONLN d ∫h ≈m )b ° d ONLN d ∫m ≈É )) / 4 = ° d ONLN d — ‹! ( ¯<( ° d ONLN d —! ‹& )c ° d ONLN d —& ‹/ ) – ° d ONLN d —/ ‹4 ) a ° d ONLN d! —4 ‹C )) / 4 ° d ONLN d' Ë Û§ (< By symmetry, the same holds for ° d ONLN dG ˧ Û≠ )Üb'' ° d ONLN dJ Ë≠ Ûπ ) = ( ° d ONLN dN Ëπ Ûæ ) b ° d ONLN dO Ëæ Û« ) + ° d ONLN dR Ë« Ûà ) c ° d ONLN dS Ëà Ûfi )) / 2. ° d ONLN dZ ˇ
¯ (&<6Thus, the formulas for the two curves that make up the ° d ONLN dë
˙ * ;left and right halves of the original curve are as follows: ° d ONLN dÕ! ,1 *Left: ° d ONLN d”!=,D ) a' ° d ONLN d’!D,G ) ° d ONLN d÷!G,N )= ° d ONLN dÿ!N,S )a ° d ONLN d€8=CD (_[b' ° d ONLN d›8DCP ) = ( ° d ONLN d·8PCU ) a ° d ONLN d‚8UC^ ) + ° d ONLN dÂ8^Cc ) b ° d ONLN dÊ8cCr )) / 2 ° d ONLN dÌO=ZD (v[c' ° d ONLN dÔODZG ) ° d ONLN dOGZQ )= ( ° d ONLN dÛOQZV )
a ° d ONLN dÙOVZd ) + 2 ° d ONLN d¯OdZi )b ° d ONLN d˘OiZr ) + ° d ONLN d¸OrZw ) c ° d ONLN d˝OwZÜ )) / 4 ° d ONLN df q6 (ç<Right: ° d ONLN d
f=qH ) a'' ° d ONLN dfHqR ) = ( ° d ONLN dfRqW )
a ° d ONLN dfWqe ) + 2 ° d ONLN dfeqj )b ° d ONLN dfjqs ) + ° d ONLN dfsqx ) c ° d ONLN dfxqá )) / 4 ° d ONLN d"}=àH (§[b'' ° d ONLN d&}HàR ) = ( ° d ONLN d)}RàY )
b ° d ONLN d+}Yà` )+ ° d ONLN d-}`àe )c ° d ONLN d.}eàt )) / 2 ° d ONLN d5î=üH (ª[c'' ° d ONLN d9îHüO ) = ° d ONLN d;îOüT )c ° d ONLN d=´ ∂ (“<5The equations for the new points are especially nice, ° d ONLN ds∂ ¡Û * 6since the arithmetic can be performed with only shifts ° d ONLN d™¡ ö * #and adds, making it very efficient. ° d ONLN dŒÿ „Ë *5Notice in Figure 4 that each of the resulting smaller ° d ONLN d „ Ó¸ * <curves is flatter than the original curve, by a factor of 4. ° d ONLN d AÓ ˘Ú * 5This means that the distance from the midpoint of the ° d ONLN d w˘ ˘ * 9curve to the midpoint of the straight line drawn from the ° d ONLN d ± ˆ * 9start point to the endpoint is reduced by 4. Thus, if the ° d ONLN d Î * 3curve is subdivided enough times, drawing the curve ° d ONLN d
%¸ * <will be equivalent to drawing a line from the start point to ° d ONLN d
\% 0Î * 7the endpoint for each of the little curves. This is the ° d ONLN d
î0 ;ƒ * )basis for drawing the curve in QuickDraw. M @c @ "d @ # d Ad6 "d7 d8d, M-c- "d- # x Bx/ , Times
({ &
+
10 4ìq·3
+md )e )v )e )l )o )p )
) Autumn 1991 ˇ^P ◊# ˇ ˇˇˇˇ # ◊
D C È Á " D C ° d
ONLN f H " È Á ° d
ONLN f ff † Ç † é
4 C B D C ò @ § @ § D C Ñ Á Î Î Î Î Î xÌ ˛Ì ˛Ì ˇÌ ˇÌ ˇÌ ˇÌ ˇÌ ˇ¿Ó ¸pÓ p Ó Ó ¿Ô pÔ , Ô <Ô H¿ X p ∞ ¿Ò ˛ pÒ Ò Ò
˛êêê Ä • æ ƒ: ȯ ' Ó ˇˇÅ ÿ Ó ˇˇÅ ÿ Ó ˇˇÅ ÿ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ó ˇÅ ◊ Ô ˛ˇ„ ˛Å ˜ Ò ˙ˇ˜ ˛ˇ˜ ˛ˇ ˇÅ ˆ Ú ¯ˇ˘ ˇ ˇˇ¯ ˇ ˇˇÅ Ù Ú ˜ˇ˚ ˇˇ˛ˇ ˛˛ˇ˛ ˇ˛ˇˇÅ Û Ú ˜ˇ˚ ˇ ˇˇ ˝ˇ˛ ˇ ˇˇÅ Û Û ˆˇ˚ ˛ˇ˜ ˛ˇÅ Ú Û ˆˇÅ ‹ Ú ˜ˇÅ ‹ Ú ¯ˇÅ € Ò ˘ˇÅ € Ô ˝ˇÅ Ÿ Å √ Å √ Å √ Å √ Å √ † è † É † ø
° d ONLN d U ê (8 6UTo represent fixed-point coordinates, we define a struct called point. Note that this ° d ONLN d ´ (h * Lis similar to QuickDraw’s Point, but uses Fixed numbers instead of integers. ,
Courier
° d ONLN d ¯5 @ h *typedef struct { ° d ONLN d
A &L N + Fixed x; ° d ONLN dM &X N * Fixed y; ° d ONLN d Y d @ (Ä 6} point;
° d ONLN d&p |y *RTo represent a curve, we need three points: a start point, a control point, and an ° d ONLN dy| à £ * endpoint. (These correspond to ° d ONLN dò| £à ∂ )ãa, b, ° d ONLN dù| ∂à À ) and ° d ONLN d¢| Àà œ )c ° d ONLN d£| œà ) in Figure 3.)
° d ONLN d≤ï † h (º 6typedef struct { ° d ONLN dƒ° &¨ b + point start; ° d ONLN d“≠ &∏ l * point control; ° d ONLN d‚π &ƒ X *
point end; ° d ONLN dÌ≈ – @ (Ï 6} curve;
° d ONLN dˆ‹ Ëë *RThe function FrameCurve (below) draws a quadratic Bézier using subdivision. If the ° d ONLN dIË Ùd * Llevel for the FrameCurve routine is 0, a LineTo (using flineto) operation is ° d ONLN dñÙ ^ * Fperformed; otherwise, the curve is subdivided and FrameCurve is called ° d ONLN d› Ö * Srecursively, once for the left half of the curve and once for the right. FrameCurve ° d ONLN d1 â * Rassumes the caller has already called fmoveto on the start point of the curve. The ° d ONLN dÑ $a * Hsecond routine, ExampleCurve, calls FrameCurve requesting four levels of ° d ONLN dÕ$ 0ç * Ysubdividing. Thus, the final curve consists of 2^4, or 16, lines. It’s shown in Figure 5. v 4v& , Times
(y)
+
11 4£ 1· Ú
(Ú50CURVES AHEAD: WORKING WITH CURVES IN QUICKDRAW
Ú ˚ Â Â Â Â Â ÄË ‡Ò ¿˙ Ò ˙ Ò ˙ ¯Ò ¯˙ ¯Ò ¯˙ ¯Ò ¯˙ ¯Ò ¯˙ Ò ˙ ¯Ò ˙ åÒ ‡˙
Ò ˘
Ò ˘ ÄÚ ˘
˛ ¿Ú ˘
˛ `Ú ˘
˛ 0Ú ˘
˛ Ú ˘
˛ Ú ˘
˛ Ú ˘
˛ Ú ˘ ˛ ¿Û ˘
˝ `Û ˘
˝ 0Û ˘
˝ Û ˘
˝ Û ˘
˝ Û ˘
˝ Û ˘ ˝ ÄÙ ˘
¸ ¿Ù ˘
¸ `Ù ˘
¸ 0Ù ˘
¸ Ù ˘
¸ Ù ˘
¸ Ù ˘
¸ Ù ˘ ¸ Äı ˘
˚ ¿ı ˘
˚ pı ˘
˚ ı ˘
˚ ı ˘
˚ ı ˘ ˚ Ĉ ˘
˙ ¿ˆ ˘
˙ `ˆ ˘
˙ 8ˆ ˘
˙ ˆ ˘
˙ ˆ 0˘ ò @ Ä ◊ @ Ä ◊ v ¥ ∂ã ˙ Ę ˘
˘ ¿˜ ˘
˘ `˜ ˘
˘ 0˜ `˘
˘ ˜ @˘
˘ ˜ ¿˘
˘ ˜ Ģ ˘ į Ģ ¯ ‡˘ Ģ
¯ 0˘ ¯
¯ ˘ ¯
¯ ˘ ¯
¯ ˘ ¯ ¯ ¿˙ ¯
˜ p˙ ¯
˜ ˙ ¯
˜ ˙ ¯ ˜ Ä˚ 0¯
ˆ ‡˚ `¯
ˆ 8˚ @¯
ˆ ˚ ¿¯ ˆ Ä˝ į
ı ¿˝ ˜
ı p˝ ˜
ı ˝ ˜
ı ˝ 0˜ ı ‡˛ ‡˜
Ù < Ę Ù ¿ ˆ Û áˆ Ú ¸ı                                  ò Ä ∞ ◊ Ä ∞ ◊ ∂ ¥ Êã Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Â Ó Ä˙ Ó ‡˙ Ó ˙ Ó F`Lhˇ Ó ?¯…ê“îˇ Ó ?¯IêRîˇ Ó ?IêRîˇ Ó IêRîˇ Ó ‡FhLdˇ Ó ¿ ˇ
Ï ˛ ˇ     òÄÿ @ ◊ H H a’L íÄ ˛ ˇˇˇˇˇˇ ˇˇˇˇÃà ˇˇˇˇôô ˇˇˇˇff ˇˇˇˇ33 ˇˇˇˇ ˇˇÃÃˇˇ ˇˇÃÃÃà ˇˇÃÃôô ˇˇÃÃff
244.4876 485.1112 246.6247 482.9742 246.6247 480.3381 c
246.6247 477.702 244.4876 475.565 241.8516 475.565 c
239.2155 475.565 237.0784 477.702 237.0784 480.3381 c
237.0784 482.9742 239.2155 485.1112 241.8516 485.1112 c
b
241.8516 480.3381 m
B
U
u
385.8516 484.6112 m
388.4876 484.6112 390.6247 482.4742 390.6247 479.8381 c
390.6247 477.202 388.4876 475.065 385.8516 475.065 c
383.2155 475.065 381.0784 477.202 381.0784 479.8381 c
381.0784 482.4742 383.2155 484.6112 385.8516 484.6112 c
b
385.8516 479.8381 m
B
U
385.8516 479.8381 m
385.1016 383.0881 336.1016 384.0881 241.8516 480.3381 c
S
0 To
1 0 0 1 234.9111 493.2863 0 Tp
TP
0 Tr
0 O
0 g
4 M
/_Helvetica 8 Tf
0 Ts
100 Tz
0 Tt
0 TA
0 0 5 TC
100 100 200 TW
0 0 0 Ti
0 Ta
0 Tq
0 0 Tl
0 Tc
0 Tw
(\(0,0\)) Tx
(\r) TX
TO
0 To
1 0 0 1 374.9111 493.2863 0 Tp
TP
0 Tr
(\(100,0\)) Tx
(\r) TX
TO
u
0 0.2 0 0 k
0 R
0 G
8 M
385.3516 340.6112 m
387.9876 340.6112 390.1247 338.4742 390.1247 335.8381 c
390.1247 333.202 387.9876 331.065 385.3516 331.065 c
382.7155 331.065 380.5784 333.202 380.5784 335.8381 c
380.5784 338.4742 382.7155 340.6112 385.3516 340.6112 c
b
385.3516 335.8381 m
B
U
0 To
1 0 0 1 397.9697 332.7863 0 Tp
TP
0 Tr
0 g
4 M
(\(100,100\)) Tx
(\r) TX
TO
%AI3_BeginCrops
userdict /AI3_noCropMarks known not {
u
u
0 R
0 G
0.5 w
190 316 m
163 316 L
S
199 307 m
199 280 L
S
U
u
190 517 m
163 517 L
S
199 526 m
199 553 L
S
U
u
468 517 m
495 517 L
S
459 526 m
459 553 L
S
U
u
468 316 m
495 316 L
S
459 307 m
459 280 L
S
U
U
} if
%AI3_EndCrops
%%PageTrailer
gsave annotatepage grestore showpage
%%Trailer
Adobe_IllustratorA_AI3 /terminate get exec
Adobe_typography_AI3 /terminate get exec
Adobe_customcolor /terminate get exec
Adobe_cshow /terminate get exec
Adobe_cmykcolor /terminate get exec
Adobe_packedarray /terminate get exec
%%EOF
Ä ◊# ˇ ˇˇˇˇ # ◊
d ,
Courier
. ° d ONLN d $ w +6@void ExampleCurve() ° d ONLN d % 0 * { ° d ONLN d 1 & <f + @static curve myCurve = {ff(0), ff(0), ff(100), ff(100), ff(100), ° d ONLN d Z = 5 H X + ff(0)}; ° d ONLN d c U & ` ¯ ( | D*fmoveto(myCurve.start.x, myCurve.start.y); ° d ONLN d è a & l û * FrameCurve(&myCurve, 4); ° d ONLN d ® m x ( î 6} , Helvetica ° d ONLN d ™ â î o * FRAMING A PATH , Palatino
° d ONLN d ∏ î †Ñ * QDrawing contours such as font outlines requires drawing a combination of straight ° d ONLN d
† ¨ ˙ * 3lines and curves. Such a combination is known as a ° d ONLN d= † ˙ ¨ )‚path ° d ONLN dA † ¨Ö ). A path is defined by the ° d ONLN d\ ¨ ∏ à ( ‘ 6following data structure:
° d ONLN dv ≈ – h *typedef struct { ° d ONLN dà — & ‹ : + long ° d ONLN dç — C ‹ p ) vectors; ° d ONLN dõ — ∑ ‹z )t'/* The number of points in the path. */ ° d ONLN dƒ › & Ë : ( Dlong ° d ONLN d… › C Ë ª ) controlBits[anyNumber]; ° d ONLN d„ È & Ù £ ( Dpoint vector[anyNumber]; ° d ONLN d˛ È ∑ Ù )ë/* The points. */ ° d ONLN d ı ; ( 6} path;
° d ONLN d ê *VA path is similar to a polygon except that it has a set of control bits that determine ° d ONLN do $z * Rwhether each point is on or off the curve. There’s one control bit for each point, ° d ONLN d¬$ 0S * Kbeginning with the most significant bit for point 0. If the bit is set, the ° d ONLN d0 <ç * Vcorresponding point is an off-curve point and therefore the control point for a curve. ° d ONLN de< Hy * RIf the bit is clear, the corresponding point is an on-curve point and therefore an ° d ONLN d∏H Tx * Oendpoint for either a line segment or a curve segment. Two consecutive on-curve ° d ONLN dT ` í * points form a straight line. ° d ONLN d&l xê *THere’s a routine that takes an index and the control bits and returns TRUE (nonzero) ° d ONLN d{x Ñ ë * if the point is on the curve:
° d ONLN di‰ w *NTwo consecutive off-curve points imply an on-curve point at their midpoint, as ° d ONLN d∏ ¸à * Tshown in Figure 6. This path consists of two curve segments. The first is defined by ° d ONLN d
¸ / * a, b, ° d ONLN d¸ / 3 )( ° d ONLN d¸ 3 : )b ° d ONLN d¸ : B )+ ° d ONLN d¸ B F )c ° d ONLN d¸ F Ø )) / 2 and the second by ( ° d ONLN d3¸ Ø ∂ )ib ° d ONLN d5¸ ∂ æ )+ ° d ONLN d7¸ æ ¬ )c ° d ONLN d8¸ ¬ Ÿ )) / 2, ° d ONLN d?¸ Ÿ Î )c, d. ° d ONLN dE l (< 6OThis ability to store a series of off-curve points allows a path to describe an ° d ONLN dï ,à * Oarbitrarily complex shape without having to store unneeded intermediate points. ° d ONLN dÂ, 8Ü * PHowever, this is just a storage nicety. When we draw the path, we need it broken ° d ONLN d68 D h * down into a series x 4x& , Times
({)
+
13
4ì Ú·Ø
(Ú50CURVES AHEAD: WORKING WITH CURVES IN QUICKDRAW
)Œ Autumn 1991 ˇ2@ ◊# ˇ ˇˇˇˇ # ◊
6 ¥ ›r " 6 ¥ ° d
ONLN f H " ›r ° d
ONLN f f∞ † Ç † é
4 5 ≥ 6 ¥ ò @ æ @ æ 6 ¥ vr È È È È È ˆ ı ˆ ~ ˜ ˆ ˇ ˜
Ó ˇ† ˛ˇª Ó ˇû ˇˇº Ó ˇù ˇˇ˜ ˇˇ… Ó ˇú ˇˇ˘ ˇˇ» Ó ˇõ ˛ˇ¸ ˇˇ« Ó ˇô ˇˇ˛ ˇˇΔ Ó ˇò ˇˇ ˇˇ≈
Ó ˇó ˛ˇƒ
Ó ˇó ˛ˇƒ Ó ˇò ˇˇ ˛ˇΔ Ó ˇô ˇˇ˝ ˇΔ Ó ˇö ˇˇ¸ ˇˇ« Ó ˇö ˇ˙ ˇˇ» Ó ˇ≠ ˇÊ ˇ» Ó ˇÆ ˇ ˇˇ˜ ˛ˇı ˇˇ… Ó ˇÆ ˇˇ˛ˇ ˛˚ ˇ ˇˇÙ ˇˇ Ó ˇØ ˇ ˇ˛ ˇ¸ ˇÔ ˇˇÀ Ó ˇØ ˇ ˇˇ˛ ˇ¸ ˇ ˇˇÒ ˇÀ Ó ˇ∞ ˇ ˛ˇ˝ ˇ¸ ˛ˇˇ ˇˇÃ Ó ˇç ˇˇÕ Ó ˇå ˇˇŒ
Ó ˇã ˇŒ Ó ˇã ˇˇœ òÄæ @ Ä æ H H a’L ñÄ ˛ ˇˇˇˇˇˇ ˇˇˇˇÃà ˇˇˇˇôô ˇˇˇˇff ˇˇˇˇ33 ˇˇˇˇ ˇˇÃÃˇˇ ˇˇÃÃÃà ˇˇÃÃôô ˇˇÃÃff
˛êêê Ä ß æ ∂ ¥ ›r ' Ó ˇÅ Ù ˇÂ Ó ˇÅ Ù ˇÂ Ó ˇÅ Ù ˇÂ Ó ˇÅ Ù ˇÂ Ó ˇÅ Ù ˇÂ Ó ˇÅ Ù ˇÂ Ó ˇÅ Ù ˇÂ Ó ˇÅ Ù ˇÂ Ó ˇÅ Ù ˇÂ Ó ˇÅ Ù ˇÂ
Ó ˇÅ Ù ˇˇÊ Ó ˇÅ Û ˇÊ Ó ˇÅ Û ˇÊ Ó ˇÅ Û ˇÊ Ó ˇÅ Û ˇÊ Ó ˇÅ Û ˇÊ Ó ˇÅ Û ˇÊ Ó ˇÅ Û ˇÊ Ó ˇÅ Û ˇÊ Ù ˛ˇ˛ ˇÅ Û ˇÊ ı ˇ ˇˇ˛ ˇÅ Û ˇÒ ˇ˜ ˆ ˛˛ˇ˝ ˇÅ Û ˇÙ ˛ˇˆ ˆ ˇ ˇ¸ ˇÅ Û ˇı ˇ ˇˆ ˆ ˛ˇ¸ ˇÅ Û ˇˇ˜ ˇ ˇı Ò ˚ˇÅ ˜ ˚ˇ˘ ˇ ˛ı Ú ˘ˇÅ ˘ ˘ˇ˙ ˛ˇÙ Ú ¯ˇÅ ˙ ¯ˇÎ Û ˜ˇÅ ˚ ˜ˇÎ Û ÅˇÊˇÏ Û ˜ˇÅ ˚ ˜ˇÎ Ú ¯ˇÅ ˙ ¯ˇÎ Ú ¯ˇÅ ˙ ¯ˇÎ Ú ˘ˇÅ ˘ ˘ˇÍ Ô ˛ˇÅ Ù ˛ˇË Å √ Å √ Å √ Å √ Å √ † è † É † ø
d , Helvetica
. ° d ONLN d « ñ “ æ +¥ÓFigure 6 ° d ONLN d ” ñ fiW * .On-Curve Point Implied by Two Off-Curve Points , Palatino
° d ONLN d 8 ˆ ñ÷ *$Iof line and curve segments. This is done with an iterator function called ° d ONLN d Ç ñ * TNextPathSegment. It’s called continuously, each time filling a record that is either ° d ONLN d ◊ ñî * :a line segment or a curve segment, until it returns FALSE. ,
Courier
° d ONLN d' ñ2 Ê *typedef struct { ° d ONLN d$3 §> Ω + int ° d ONLN d)3 Ω> ¬ ) ° d ONLN d*3 ≈> Ë )isLine; ° d ONLN d3? §J Ω (f ¬curve ° d ONLN d8? ΩJ ¬ ) ° d ONLN d9? ≈J œ )c; ° d ONLN d=W §b Í (~ ¬/* Private. */ ° d ONLN dMc §n Ω * long ° d ONLN dRc Ωn ¬ ) ° d ONLN dSc ≈n „ )index; ° d ONLN d[o §z Ω (ñ ¬long ° d ONLN d`o Ωz ¬ ) ° d ONLN dao ≈z ‘ )ep; ° d ONLN df{ §Ü Ω (¢ ¬long ° d ONLN dk{ ΩÜ ¬ ) ° d ONLN dl{ ≈Ü „ )*bits; ° d ONLN dtá §í Ω (Æ ¬point ° d ONLN dyá Ωí ¬ ) ° d ONLN dzá ≈í ‘ )*p; ° d ONLN d~ì ñû ◊ (∫ ¥
} pathWalker; ° d ONLN då´ ñ∂Å */void InitPathWalker(pathWalker *w, path *aPath) ° d ONLN dº∑ ñ¬ õ * { ° d ONLN dø√ §Œ  +
w->index = 0; ° d ONLN dŒœ §⁄+ * w->ep = aPath->vectors - 1; ° d ONLN d΀ §Ê5 * w->bits = aPath->controlBits; ° d ONLN d
Á §Ú’ * =/* Skip past the control bits to point to the first point. */ ° d ONLN dIÛ §˛∑ * 7w->p = (point *)(w->bits + (aPath->vectors + 31 >> 5)); ° d ONLN dÅˇ ñ
334.4456 566.0659 336.5827 563.9289 336.5827 561.2928 c
336.5827 558.6567 334.4456 556.5197 331.8096 556.5197 c
329.1735 556.5197 327.0364 558.6567 327.0364 561.2928 c
327.0364 563.9289 329.1735 566.0659 331.8096 566.0659 c
b
331.8096 561.2928 m
B
U
u
404.5596 493.3159 m
407.1956 493.3159 409.3327 491.1789 409.3327 488.5428 c
409.3327 485.9067 407.1956 483.7697 404.5596 483.7697 c
401.9235 483.7697 399.7864 485.9067 399.7864 488.5428 c
399.7864 491.1789 401.9235 493.3159 404.5596 493.3159 c
b
404.5596 488.5428 m
B
U
259.3096 558.7928 m
363.3096 557.7928 401.8096 507.7928 403.3096 415.2928 c
259.3096 415.2928 l
259.3096 558.7928 l
s
0 To
1 0 0 1 344.3467 560.7411 0 Tp
TP
0 Tr
0 O
0 g
4 M
/_Helvetica-Oblique 8 Tf
0 Ts
100 Tz
0 Tt
0 TA
0 0 5 TC
100 100 200 TW
0 0 0 Ti
0 Ta
0 Tq
9 0 Tl
0 Tc
0 Tw
(b) Tx
(\r) TX
TO
0 To
1 0 0 1 416.8467 487.4911 0 Tp
TP
0 Tr
(c) Tx
(\r) TX
TO
0 To
1 0 0 1 249.1682 549.2411 0 Tp
TP
0 Tr
(a) Tx
(\r) TX
TO
0 To
1 0 0 1 249.3467 420.7411 0 Tp
TP
0 Tr
(e) Tx
(\r) TX
TO
0 To
1 0 0 1 412.8467 417.9911 0 Tp
TP
0 Tr
(d) Tx
(\r) TX
TO
0 To
1 0 0 1 349.0596 512.2928 0 Tp
TP
-8.9102 0 Td
0 Tr
1 Ta
(b) Tx
( ) Tx
/_Futura-Book 8 Tf
(+) Tx
/_Helvetica-Oblique 8 Tf
( c) Tx
(\r) TX
TO
0 R
0 G
8 M
336.0597 507.7928 m
363.5597 507.7928 l
B
0 To
1 0 0 1 348.2026 495.0428 0 Tp
TP
0 Tr
4 M
/_Helvetica 8 Tf
0 Ta
(2) Tx
(\r) TX
TO
0 R
0 G
8 M
363.5596 518.7928 m
373.3096 528.5428 l
B
u
403.3096 420.0659 m
405.9456 420.0659 408.0827 41 ° ¿K7.9289 408.0827 415.2928 c
408.0827 412.6567 405.9456 410.5197 403.3096 410.5197 c
400.6735 410.5197 398.5364 412.6567 398.5364 415.2928 c
398.5364 417.9289 400.6735 420.0659 403.3096 420.0659 c
b
403.3096 415.2928 m
B
U
u
259.3096 563.5659 m
261.9456 563.5659 264.0827 561.4289 264.0827 558.7928 c
264.0827 556.1567 261.9456 554.0197 259.3096 554.0197 c
256.6735 554.0197 254.5364 556.1567 254.5364 558.7928 c
254.5364 561.4289 256.6735 563.5659 259.3096 563.5659 c
b
259.3096 558.7928 m
B
U
u
259.3096 420.0659 m
261.9456 420.0659 264.0827 417.9289 264.0827 415.2928 c
264.0827 412.6567 261.9456 410.5197 259.3096 410.5197 c
256.6735 410.5197 254.5364 412.6567 254.5364 415.2928 c
254.5364 417.9289 256.6735 420.0659 259.3096 420.0659 c
b
259.3096 415.2928 m
B
U
%AI3_BeginCrops
userdict /AI3_noCropMarks known not {
u
u
0.5 w 4 M
231.5 398 m
204.5 398 L
S
240.5 389 m
240.5 362 L
S
U
u
231.5 577 m
204.5 577 L
S
240.5 586 m
240.5 613 L
S
U
u
441 577 m
468 577 L
S
432 586 m
432 613 L
S
U
u
441 398 m
468 398 L
S
432 389 m
432 362 L
S
U
U
} if
%AI3_EndCrops
%%PageTrailer
gsave annotatepage grestore showpage
%%Trailer
Adobe_IllustratorA_AI3 /terminate get exec
Adobe_typography_AI3 /terminate get exec
Adobe_customcolor /terminate get exec
Adobe_cshow /terminate get exec
Adobe_cmykcolor /terminate get exec
Adobe_packedarray /terminate get exec
%%EOF
é ◊# ˇ ˇˇˇˇ # ◊
d ,
Courier
. ° d ONLN d % & 0 Ä +DLif (w->index == 0) ° d ONLN d % ö 0b )t(/* 0 means this is the first segment. */ ° d ONLN d > 1 & < + ( X D{ ° d ONLN d @ 1 5 < ¡ ) if (OnCurve(w->bits, w->ep)) ° d ONLN d ` = C H ¿ + w->c.start = w->p[w->ep]; ° d ONLN d | I 5 T I ( p Selse ° d ONLN d É U 5 ` : * { ° d ONLN d Ö U C ` ∂ )if (OnCurve(w->bits,0)) ° d ONLN d † a C l H * { ° d ONLN d ¢ a R l ª )w->c.start = w->p[0]; ° d ONLN d º m R x ì *
NEXT_SEGMENT: ° d ONLN d ˝ &R + </* Compute the point index before and after the current one. ° d ONLN d &a * ? * This wraps around, since we assume the contour is closed. */ ° d ONLN dI & * 1prevIndex = w->index == 0 ? w->ep : w->index - 1; ° d ONLN d|! &, * 1nextIndex = w->index == w->ep ? 0 : w->index + 1; ° d ONLN dØ9 &D ¡ * if (OnCurve(w->bits, w->index)) ° d ONLN d–E &P + * { ° d ONLN d“E 5P ’ ) if (OnCurve(w->bits, prevIndex)) ° d ONLN dıQ 5\ : * { ° d ONLN d˜Q C\ ò )w->isLine = true; ° d ONLN d
Q ∑\W )t /* This means we have a line. */ ° d ONLN d.] Ch ≈ (Ñ aw->c.end = w->p[w->index]; ° d ONLN dKi 5t : (ê S} ° d ONLN dOu 5Ä Δ * else if (w->index++ <= w->ep) ° d ONLN dpÅ Cå ù + goto NEXT_SEGMENT; ° d ONLN dÑç &ò + (¥ D} ° d ONLN dáô &§ : * else ° d ONLN dç• &∞ + * { ° d ONLN dè• 5∞ è )w->isLine = false; ° d ONLN d§• ∑∞\ )Ç!/* This means we have a curve. */ ° d ONLN d»± 5º À (ÿ S w->c.control = w->p[w->index]; ° d ONLN dÈΩ 5» ’ * if (OnCurve(w->bits, nextIndex)) ° d ONLN d
… C‘ + w->c.end = w->p[nextIndex]; ° d ONLN d+’ 5‡ I (¸ Selse ° d ONLN d2· 5Ï : * { ° d ONLN d4· CÏQ )6w->c.end.x = AVE(w->p[w->index].x, w->p[nextIndex].x); ° d ONLN dnÌ C¯Q * 6w->c.end.y = AVE(w->p[w->index].y, w->p[nextIndex].y); ° d ONLN dߢ 5 : ( S} ° d ONLN d™ & + (, D} ° d ONLN d≠ &( ≠ *return w->index++ <= w->ep; ° d ONLN d… ∑(\ )ë!/* Return TRUE if there are still ° d ONLN dˆ) ∑4 * * more segments. */ ° d ONLN d 5 @ (\ 6} x 4x& , Times
({) , Helvetica
+
15
4ì Ú·Ø
(Ú50CURVES AHEAD: WORKING WITH CURVES IN QUICKDRAW
)Œ Autumn 1991 ˇ
2 ◊# ˇ ˇˇˇˇ # ◊
d , Palatino
. ° d ONLN d $ ñ 0 +¥LNThe FramePath routine uses a pathWalker to traverse the path and draw it as it ° d ONLN d O 0 ñ < ¨ * goes. ,
+ if (walker.isLine) ° d ONLN dãQ ¡\â + (flineto(walker.c.end.x, walker.c.end.y); ° d ONLN d∂] ≥h « (Ñ —else ° d ONLN dæi ¡tp + #FrameCurve(&walker.c, kCurveLimit); ° d ONLN d„u §ÄÛ (ú ¬C/* Return the next path, used if this path is one of several within ° d ONLN d)Å §å * * a series of paths. */ ° d ONLN dCç §ò * return NextPath(cont); ° d ONLN dZô ñ§ õ (¿ ¥}
° d ONLN d∑’ ñ‡ *void ExamplePath() ° d ONLN d · ñÏ õ * { ° d ONLN dÕÌ §¯ ˘ + long myPath[] = { ° d ONLN d·˘ ≥ Ω + 5, ° d ONLN dÁ˘ ˚_ )H /* Five points. */ ° d ONLN d˛ ≥ Í (, — 0x60000000, ° d ONLN d
˚ı )H2 /* The second and third are off-curve points. */ ° d ONLN d? ≥ Û (8 —@0,0,ff(10),0,ff(20),ff(10),ff(20),ff(20),0,ff(20) /* x,y data */ ° d ONLN dÅ §( Æ (D ¬}; ° d ONLN dÖ5 §@& *FramePath((path *)myPath); ° d ONLN d†A ñL õ (h ¥} x Bx/ , Times
({ & , Helvetica
+
16
4ìq·3
+md )e )v )e )l )o )p )
) Autumn 1991 ˇ P ◊# ˇ ˇˇˇˇ # ◊
d , Helvetica
. ° d ONLN d ) 4 +6P%FRAMING A SHAPE MADE OF SEVERAL PATHS , Palatino
° d ONLN d & 4 @Ü * TTo describe a shape that contains several disjoint paths (such as an outline letter ° d ONLN d z 4Ü @ã ( \§o ° d ONLN d { 4ã @í )), ° d ONLN d ~ @ L} ( h 6Rwe use a simple data structure that’s just a composite of several path structures: ,
Courier
° d ONLN d — Y d c *typedef struct{ ° d ONLN d ‚ e & p : + long ° d ONLN d Á e C p u )
contours; ° d ONLN d Û q & | : ( ò Dpath ° d ONLN d ¯ q C | ß ) contour[anyNumber]; ° d ONLN d
} à @ ( § 6} paths;
° d ONLN d î † ˘ *1Drawing such a shape (called in the vernacular a ° d ONLN dG î ˘ † )·paths ° d ONLN dL î †r )) is straightforward:
° d ONLN dì +í *RNow that you know how to give your application the capability to draw all sorts of ° d ONLN dÊ+ 7ã * Ocurved shapes on the screen or on a QuickDraw printer, you might wonder whether ° d ONLN d67 Cl * Lyou can cut and paste these shapes into other applications or send them to a x 4x& , Times
({)
+
17
4ì Ú·Ø
(Ú50CURVES AHEAD: WORKING WITH CURVES IN QUICKDRAW
ñ æ (1 ¥Figure 7 ° d ONLN d ñ! * A Shape Made of Several Paths , Palatino
° d ONLN d '6 ñB *!SPostScript printer. The answer is yes, thanks to picture comments. Picture comments ° d ONLN d {B ñN * Kencapsulate non-QuickDraw graphics data that other “smarter-than-QuickDraw” ° d ONLN d «N ñZ * applications can interpret. ° d ONLN d ‰f ñr¸ *NFortunately, there’s a picture comment that takes quadratic Bézier information ° d ONLN d3r ñ~˙ * Mdirectly: PolySmooth. When this comment is encountered in a PICT it indicates ° d ONLN dÅ~ ñä * Sthat the endpoints of the following lines are control points of a quadratic Bézier. ° d ONLN d’ä ññ * QUnfortunately, the comment assumes that all the control points lie off the curve. ° d ONLN d'ñ ñ¢ * PThis is a major drawback of the PolySmooth comment and forces us to break a path ° d ONLN dx¢ ñÆ
* Udown into curves and lines, rather than allowing us to put an entire path in at once. ° d ONLN dœ∫ ñΔ¸ *MWhen a picture interpreter (such as the LaserWriter driver) sees a PolySmooth ° d ONLN d Δ ñ“ * Upicture comment, it interprets the following points (put in the picture with a LineTo ° d ONLN ds“ ñfi˘ * Oopcode) as off-curve control points. Since DrawPicture ignores picture comments ° d ONLN d√fi ñÍ * Ucompletely, the clipping rectangle is set to empty so that no drawing will occur. The ° d ONLN dÍ ñˆ * Rpicture interpreter now has the control points and can render the curve however it ° d ONLN dlˆ ñ π * sees fit. ° d ONLN dv ñ˘ *NTo save a path in a picture, we start with the PolyBegin picture comment. This ° d ONLN d≈ ñ&
* Scomment indicates that a special polygon follows. If the path is closed, we add the ° d ONLN d& ñ2 * QpicPlyClo comment. Then we set the clipping to empty so that DrawPicture will not u Bu/ , Times
(x &
+
18
+ã ,For more information about picture comments, * +see Technical Note #91, “Optimizing for the * -LaserWriter—Picture Comments.” This tech note * 2explains how picture comments work and documents a * 4number of standard picture comments supported by the * LaserWriter printer driver.• 4êqÍ3
255.2959 358.585 270.6214 325.079 269.7822 287.3352 C
306.5053 323.5127 L
343.0038 287.7645 L
342.7035 345.5168 377.2454 359.7264 414.9984 359.75 C
414.692 359.8503 L
379.1184 396.0263 L
415.0445 432.35 L
357.2913 432.3317 342.2431 465.4476 342.4038 503.2003 C
342.5015 503.4996 L
306.2502 467.5001 L
270.2508 503.7514 L
269.75 446 236.5 431.25 198.75 431.75 C
198.4528 431.85 L
s
4 M
306 286.6782 m
287.25 285.4282 281.8534 300.9241 281.75 307.1782 c
281.25 337.4282 295 381.6782 305.25 381.9282 C
306.75 381.9282 L
317 381.6782 330.75 337.4282 330.25 307.1782 c
330.1466 300.9241 324.75 285.4282 306 286.6782 C
s
415.2371 396.6065 m
416.2473 415.371 400.6836 420.5691 394.4286 420.5925 c
364.1745 420.7057 320.1037 406.3909 319.9848 396.1385 C
320.004 394.6386 L
320.385 384.3926 364.8075 371.2094 395.0488 372.0962 c
401.3011 372.2795 416.7268 377.8739 415.2371 396.6065 C
s
197.477 396.6065 m
196.4668 415.371 212.0305 420.5691 218.2855 420.5925 c
248.5396 420.7057 292.6104 406.3909 292.7293 396.1385 C
292.7101 394.6386 L
292.3291 384.3926 247.9066 371.2094 217.6653 372.0962 c
211.413 372.2795 195.9873 377.8739 197.477 396.6065 C
s
306 503.3929 m
287.25 504.6429 281.8534 489.1471 281.75 482.8929 c
281.25 452.6429 295 408.3929 305.25 408.1429 C
306.75 408.1429 L
317 408.3929 330.75 452.6429 330.25 482.8929 c
330.1466 489.1471 324.75 504.6429 306 503.3929 C
s
%AI3_BeginCrops
userdict /AI3_noCropMarks known not {
u
u
0.5 w
180 273 m
153 273 L
S
189 264 m
189 237 L
S
U
u
180 514 m
153 514 L
S
189 523 m
189 550 L
S
U
u
435 514 m
462 514 L
S
426 523 m
426 550 L
S
U
u
435 273 m
462 273 L
S
426 264 m
426 237 L
S
U
U
} if
%AI3_EndCrops
%%PageTrailer
gsave annotatepage grestore showpage
%%Trailer
Adobe_IllustratorA_AI3 /terminate get exec
Adobe_customcolor /terminate get exec
Adobe_cshow /terminate get exec
Adobe_cmykcolor /terminate get exec
Adobe_packedarray /terminate get exec
%%EOF
à ◊# ˇ ˇˇˇˇ # ◊
d , Palatino
. ° d ONLN d $ 0é +6LNrender the following data. Next we add the PolySmooth comment, followed by the ° d ONLN d O 0 < X * control points. ° d ONLN d ` H TÉ *QWhen the whole polygon is in the picture, we restore the clipping to its previous ° d ONLN d ≤ T `Å * Mstate and add the PolyIgnore picture comment. Anyone reading picture comments ° d ONLN d ` lê * Owill know to ignore the following QuickDraw polygon. DrawPicture, which ignores ° d ONLN dP l xv * Nall picture comments and skips over the smooth polygon since the lines are all ° d ONLN dü x Ñ * 5clipped out, will draw the polygon just as it should. ° d ONLN d’ ê úç *QThus, we have something like the following (where an asterisk indicates a picture ° d ONLN d' ú ® F * comment): ° d ONLN d1 ¥ ¿ v *Save the current clip ° d ONLN dG ¬ Œ L *
*PolyBegin ° d ONLN dR – ‹ *7Set the clip to the empty rectangle to turn off drawing ° d ONLN dä fi Í U * *PolySmooth ° d ONLN dñ Ï ¯B *ERecord the PostScript version of the curves (just the control points) ° d ONLN d‹ ˙ N * *PolyIgnore ° d ONLN dË Ò *1Restore the original clip to turn drawing back on ° d ONLN d "a *HRecord the QuickDraw version of the curves (subdivided into short lines) ° d ONLN dc$ 0 C **PolyEnd ° d ONLN dl< Hà *QSince the PolySmooth picture comment allows only off-curve points, it’s necessary ° d ONLN dæH Tç * Qto break the path down into segments. This is done by the AddPathsToPict routine, ° d ONLN dT `à * Nwhich calls AddSegmentToPict for each path fragment (either a single quadratic ° d ONLN d_` l} * PBézier or a line). AddSegmentToPict copies two sets of points into the PICT, one ° d ONLN d∞l xÑ * Tthat contains the actual control points of the curve or line segment (for PostScript ° d ONLN dx Ñé * Pprinting or pasting into MacDraw) and another that is the QuickDraw rendering of ° d ONLN dVÑ ê d * the curve or line. ° d ONLN djú ®} *PIn AddSegmentToPict (below), cur is the current segment to be added; isLine is a ° d ONLN dª® ¥ * OBoolean identifying whether the segment is a curve or a line segment; and delta ° d ONLN d ¥ ¿| * Pspecifies an amount to offset the data when recording the PostScript version, to ° d ONLN d\¿ Ãê * Raccount for the difference between PostScript’s centered pen and QuickDraw’s upper ° d ONLN dØà ÿ > * left pen. ,
Courier
° d ONLN dπ ? *;void AddSegmentToPict(curve *cur, point *delta, int isLine) ° d ONLN dıÒ ¸ * { ° d ONLN d¯˝ & À + !/* Real programs check errors. */ ° d ONLN d & D * Handle ° d ONLN d# d ◊ )>verbHdl = NewHandle(1); ° d ONLN d< & S (< D RgnHandle ° d ONLN dF d » )>origClip = NewRgn(); ° d ONLN d\! &, : (H DRect ° d ONLN dc! d, · )>emptyRect = {0, 0, 0, 0}; x 4x& , Times
({) , Helvetica
+
19
4ì Ú·Ø
(Ú50CURVES AHEAD: WORKING WITH CURVES IN QUICKDRAW
)Œ Autumn 1991 ˇ
f ◊# ˇ ˇˇˇˇ # ◊
d ,
Courier
. ° d ONLN d § $ +¬@**verbHdl = kPolyFrame; ° d ONLN d % § 0 ˛ * GetClip(origClip); ° d ONLN d - = § H0 * PicComment(POLYBEGIN, 0, 0); ° d ONLN d K I § T
Õ! ÿÀ )}" /* This turns drawing back on. */ ° d ONLN d2 Ÿ ≥ ‰l ( —%/* Record the lines for QuickDraw. */ ° d ONLN dZ Â ≥ g * $fmoveto(cur->start.x, cur->start.y); ° d ONLN dÅ Ò ≥ ¸ Í * if (isLine) ° d ONLN dê ˝ ¡a + flineto(cur->end.x, cur->end.y); ° d ONLN d≥ ≥ « (0 —else ° d ONLN dª ¡ R + FrameCurve(cur, kCurveLimit); ° d ONLN d⁄! §,& (H ¬PicComment(POLYEND, 0, 0); ° d ONLN dˆ9 §D
*DisposeRgn(origClip); ° d ONLN d
E §P * DisposHandle(verbHdl); ° d ONLN d$Q ñ\ õ (x ¥} , Palatino
° d ONLN d&h ñt *IAddPathsToPict is relatively simple. It walks through each path, and each ° d ONLN dpt ñÄ * Osegment within each path, and records the segments by calling AddSegmentToPict.
° d ONLN d¿ç ñò, * AddPathsToPict(paths *myPaths) ° d ONLN dflô ñ§ õ * { ° d ONLN d‚• §∞ Ω + point ° d ONLN dË• √∞ ) penDelta; ° d ONLN dÛ± §º ∏ (ÿ ¬long ° d ONLN d¯± √º Õ ) i; ° d ONLN d¸Ω §» ∏ (‰ ¬path ° d ONLN dΩ √» · ) *cont; ° d ONLN d ’ §‡Ó (¸ ¬B/* Compute half the pen's thickness as a delta, since PostScript's ° d ONLN dM· §ÏÓ * B * pen is centered and QuickDraw's hangs to the right and down. */ ° d ONLN dëÌ §¯g * 'penDelta.x = ff(thePort->pnSize.h) / 2; ° d ONLN d∫˘ §g * 'penDelta.y = ff(thePort->pnSize.v) / 2; ° d ONLN d„ § 0 * /* Record the curve data. */ ° d ONLN d §( * cont = myPaths->contour; x Bx/ , Times
({ & , Helvetica
+
20
4ìq·3
+md )e )v )e )l )o )p )
) Autumn 1991 ˇ∂ ◊# ˇ ˇˇˇˇ # ◊
d ,
Courier
. ° d ONLN d & $ È +D@'for (i = 0; i < myPaths->contours; i++) ° d ONLN d ) % & 0 + * { ° d ONLN d + % 5 0 è )pathWalker walker; ° d ONLN d @ = 5 H *+/* This loop looks a lot like FramePath. */ ° d ONLN d n I 5 T À * InitPathWalker(&walker, cont); ° d ONLN d è U 5 ` ’ * while (NextPathSegment(&walker)) ° d ONLN d ≥ a C lQ + 6AddSegmentToPict(&walker.c, &penDelta, walker.isLine); ° d ONLN d Ï m 5 x £ ( î Scont = NextPath(cont); ° d ONLN d y & Ñ + ( † D} ° d ONLN d Ö ê ( ¨ 6} , Palatino
° d ONLN d ú ®a *HA word about rounding: We’ve kept all our data in Fixed, even during the ° d ONLN dQ ® ¥É * Ssubdivision process, up until calling LineTo; still, when we record the data into a ° d ONLN d• ¥ ¿Ö * PPICT, we’re forced to throw away information since the PICT records only integer ° d ONLN dˆ ¿ Ãv * Mcoordinates. The upshot of this is that a given series of paths may draw much ° d ONLN dD à ÿt * Nbetter in your application than when it’s been put into a PICT and pasted into ° d ONLN dì ÿ ‰ w * another application. , Helvetica
° d ONLN d… Ä *OBecause TrueType uses the quadratic Bézier as its curve primitive, as mentioned ° d ONLN d y * Rearlier, the outlines in a TrueType font represent a rich source of curve data for ° d ONLN dl +á * Lprogrammers. In fact, a program demonstrated at Apple’s Worldwide Developers ° d ONLN dπ+ 7ä * TConference in May of this year uses TrueType fonts as a basis for turning text typed ° d ONLN d7 Cu * Pby the user into outlines that can be rotated, filled, stretched and shrunk, and ° d ONLN d_C O{ * Otransformed in other amusing ways. All it takes to produce such a program is to ° d ONLN dØO [å * Tconvert TrueType data from its native storage structure into a paths data structure. ° d ONLN d[ gç * PWe show you how to do that here, and then discuss the sample program you’ll find ° d ONLN dUg s 6 * on the ° d ONLN d\g 6s ï ) Developer CD Series ° d ONLN dog ïsê )_8 disc that draws outlines extracted from TrueType fonts.
° d ONLN d®Ñ è ë (´ 6CONVERTING THE DATA
° d ONLN dºè õt * OFor space reasons, the data for TrueType outlines is not stored in a paths data ° d ONLN d õ ß{ * Qstructure but instead is compressed as byte deltas. Code provided on this issue’s ° d ONLN d^ß ≥ w * Developer CD Series ° d ONLN dqß w≥ä )_? disc fills out a glyph outline data structure given a TrueType ° d ONLN d±≥ øP (€ 6Ffont and a glyph ID. The glyph outline data structure looks like this:
+ˇI0CURVES AHEAD: WORKING WITH CURVES IN QUICKDRAW
)Œ Autumn 1991 ˇ ◊# ˇ ˇˇˇˇ # ◊
d , Palatino
. ° d ONLN d $ ñ 0Ò +¥LOA glyph outline is a bit less compact than a paths data structure, but contains ° d ONLN d P 0 ñ <˝ * Oenough information to be converted into one. One difference from the paths data ° d ONLN d † < ñ H * Zstructure is that in a path, if a control bit is set, the point is treated as an off-curve ° d ONLN d ˚ H ñ T˚ * Tpoint. In a glyph outline, if the onCurve byte is set, the point is treated as an on ° d ONLN dO H˚ Tˇ ( p- ° d ONLN dP T ñ `˚ ( | ¥Rcurve point. Another difference is that in a glyph outline, the points for all the ° d ONLN d£ ` ñ l· * Jcontours are stored contiguously, rather than separated into discrete path ° d ONLN dÓ l ñ x ƒ * structures. ° d ONLN d˚ Ñ ñ ê *QThe utility function PackControlBits takes an array of bytes, each representing a ° d ONLN dM ê ñ ú * Vpoint, and packs them into a bit array, suitable for a path. It then returns a pointer ° d ONLN d§ ú ñ ®> * (to the long after the last control long. ,
Courier
° d ONLN dÕ µ ñ ¿≥ *9long *PackControlBits(long *p, Byte *onCurve, long count) ° d ONLN d ¡ ñ Ã õ * { ° d ONLN d
° d ONLN d¡Ä ñå *QThe function OutlineToPaths takes a glyph outline and returns a pointer to a path ° d ONLN då ñò * Sthat represents the outline. NewPtr is called, so when the application has finished ° d ONLN dgò ñ§N * )using the path it should call DisposePtr.
° d ONLN dÊ¥ ¿ ÿ (‹ 6(The sample application QD Curves on the ° d ONLN d¥ ÿ¿7 )¿Developer CD Series ° d ONLN d!¥7¿á )_ disc uses paths to ° d ONLN d5¿ Ã~ (Ë 6Qdraw the outlines of TrueType text. It can put the outlines onto the Clipboard so ° d ONLN dáà ÿg * Lthat they can be pasted into another application for editing or printing. In ° d ONLN d‘ÿ ‰ä * Saddition, the application uses some of the other TrueType access functions to build ° d ONLN d(‰ å * Rvariable-length font and style menus and display information about a font, such as ° d ONLN d{ ¸B * Cits version number, copyright notice, and trademark (see Figure 8). ° d ONLN dø é *QTo display a path, the application determines how large the path currently is and ° d ONLN d } * Pscales it to fill the window. The utility functions OffsetPaths, ScalePaths, and ° d ONLN db , * 9GetPathsBounds are used in positioning and scaling paths. x 4x& , Times
({)
+
23
4ì Ú·Ø
(Ú50CURVES AHEAD: WORKING WITH CURVES IN QUICKDRAW
ñ õ (4 ¥} ° d ONLN dÎ% ñ0w *-void ScalePaths(paths *p, Fixed sx, Fixed sy) ° d ONLN d1 ñ< õ * { ° d ONLN d = §H + long ctrs = p->contours; ° d ONLN d6I §T! * path *aPath = p->contour; x Bx/ , Times
({ &
+
24
4ìq·3
+md )e )v )e )l )o )p )
) Autumn 1991 ˇ ◊# ˇ ˇˇˇˇ # ◊
d ,
Courier
. ° d ONLN d % & 0% +DL3/* Apply the scales; remember, x comes before y. */ ° d ONLN d 5 1 & < l * while (ctrs--) ° d ONLN d E = & H + * { ° d ONLN d G = 5 H ¡ ) long pts = aPath->vectors; ° d ONLN d f I 5 T ¡ * /* Skip the control bits. */ ° d ONLN d Ö U 5 `9 * 4Fixed *coord = (Fixed *)aPath + 1 + (pts + 31 >> 5); ° d ONLN d ø m 5 x v *
while (ctr--) ° d ONLN dSi &t + * { ° d ONLN dUi 5t I )long ° d ONLN dZi Rt ‘ ) *bits = cont->controlBits; ° d ONLN dwu 5Ä ¡ (ú S /* Skip the control bits. */ ° d ONLN dñÅ 5åW * :long *coord = (long *)(bits + (cont->vectors + 31 >> 5)); ° d ONLN d”ç 5ò ∑ * long pts = cont->vectors; ° d ONLN d• 5∞ v *
while (pts--) ° d ONLN d ± 5º : * { ° d ONLN d± Cº ∂ )short x = FR(*coord++); ° d ONLN d Ω C» ∂ * short y = FR(*coord++); ° d ONLN d8’ C‡ ì *if (x < r->left) ° d ONLN dM· RÏ é + r->left = x; ° d ONLN d^Ì C¯ ± ( aelse if (x > r->right) ° d ONLN dy˘ R ì +
r->right = x; ° d ONLN dä C é (, aif (y < r->top) ° d ONLN dû R â + r->top = y; ° d ONLN dÆ C( ∂ (D aelse if (y > r->bottom) ° d ONLN d ) R4 ò + r->bottom = y; ° d ONLN d€5 5@ : (\ S} x 4x& , Times
({) , Helvetica
+
25
4ì Ú·Ø
(Ú50CURVES AHEAD: WORKING WITH CURVES IN QUICKDRAW
° d ONLN d V T ñ `˙ *QNote that what is returned is the bounds for the control points of the paths, not ° d ONLN d ® ` ñ l
* Tnecessarily the bounds of the actual paths being drawn (see Figure 9). That requires ° d ONLN d ˝ l ñ xÛ * Ma slightly more complex, though useful, function, which we leave to you as an ° d ONLN dK x ñ Ñ * exercise. (Hint: Find the ° d ONLN de x Ñ )qx ° d ONLN dg x Ñ! )and ° d ONLN dk x! Ñ) )y ° d ONLN dm x) Ñ˛ )1extrema for the curve. To do this, find the local ° d ONLN dü Ñ ñ ê » ( ¨ ¥ extrema in ° d ONLN d™ Ñ » ê Œ )2t ° d ONLN d¨ Ñ Œ êì )-by setting the derivative of the equation in ° d ONLN dŸ Ñì êö )≈x ° d ONLN d€ Ñö ê• )or ° d ONLN dfi Ñ• ê≠ ) y ° d ONLN d‡ Ñ≠ ê )equal to 0, and solve ° d ONLN dˆ ê ñ ú • ( ∏ ¥for ° d ONLN d˙ ê • ú ¨ )t. ° d ONLN d¸ ê ¨ ú ∞ ))
° d ONLN d1 ÿ ‰É *QThis function to mark the control points of a path is a good framework for adding ° d ONLN dÉ ‰ â * Rcurve editing. We leave that to you also, and suggest that besides simple point-by ° d ONLN d’ ‰â ç ( ß- ° d ONLN d÷ ¸g ( 6Kpoint direct mouse editing, you consider providing the capability to do the ° d ONLN d" ¸ G *
following: ° d ONLN d- + 1 +• ° d ONLN d/ 7S ) Bdo direct curve editing by hit-testing the curve itself instead of ° d ONLN dr 7& ì * just its control points ° d ONLN dä, +8 1 (T I• ° d ONLN då, 78> ) <select groups of points/segments to move at once, similar to ° d ONLN d…8 7D fi * &selecting multiple icons in the Finder ° d ONLN dJ +V 1 (r I• ° d ONLN dÚJ 7V. ) 7do constrain-based editing, where tangent continuity is ° d ONLN d*V 7b  * $maintained between adjacent segments ° d ONLN dOh +t 1 (ê I• ° d ONLN dQh 7tN ) Ainterpolate changes to a set of key points across the rest of the ° d ONLN dìt 7ÄC * =path, allowing, for instance, creation of a bold character by ° d ONLN d—Ä 7åW * >simply moving a few points on the stems and then smoothing out ° d ONLN då 7ò ù * the rest of the outlines , Helvetica
° d ONLN d<ª «t *NThis article has given you the tools to do some fancy work with curves in your ° d ONLN dã« ”f * Iapplications. We’ve given you routines for drawing curves and paths using ° d ONLN d’” flÑ * OQuickDraw, discussed how to save these in PICTs so that they can be loaded into ° d ONLN d%fl Îå * Nother programs like MacDraw or printed using the LaserWriter, and shown how to ° d ONLN dtÎ ˜~ * Nextract paths from TrueType fonts, giving you an abundant supply of path data. ° d ONLN d√˜ ê * UNow it’s up to you to play off this knowledge by adding curve editing, text rotation, ° d ONLN d * 9and other means of transforming your new freehand curves. x 4x& , Times
({)
+
27
(è 6!THANKS TO OUR TECHNICAL REVIEWERS *
4Pete “Luke” Alexander, Guillermo Ortiz Sean Parent •
4ì Ú·Ø
+ˇY0CURVES AHEAD: WORKING WITH CURVES IN QUICKDRAW
)Œ Autumn 1991 ˇ Ú ◊# ˇ ˇˇˇˇ # ◊
d , Helvetica
. ° d ONLN d % / 5 ç +MP
VALIDATING ° d ONLN d C = S ç + DATE AND ° d ONLN d a 1 q ç ( å O
TIME ENTRY ° d ONLN d 5 è ç + IN MACAPP 0C ,’ ¶
D -‘ • ö ˇÅÙ , ˙ ñ ñ , ˙D -‘ • @µ Á ÁΔΔ Á ÁΔ Á•!˝ Á!B! c!B˛=ÔBBF1B=Ô=Ô˛B=Ô=ÔBF1˙B=ÔF1˝B =Ô=ÔBJR9Œ%))J cBB˝ cÑÑ•˛Δ
ÁΔ Á Á! Á%)! Á%))J˛-k"5≠1å5≠)J-k)J=Ô-k%) Á)J)J1å1å5≠5≠9Œ9Œ5≠5≠=Ô1å5≠9Œ1å5≠5≠1å1å-k5≠1å1å-k1å˛)J-k-k)J%)-k)J)J%))J%))J%)%)!%)¸! %)˛!%)!%)%) Á˚!%)%)!!%)!%)!˛%)!!%)%)˝!2%)!%)%)!%)!•B c cB•B%)VµJRJR)J)J-k%)-k-k%)=ÔNsJRJR Á%) Á!%)1å1å9ŒBF1JRJRF1JRF1F1NsNsJRJRNsRî˛JR
F1B=Ô=ÔF19ŒB=Ô9Œ=Ô=Ô˛9Œ˛=Ô˛9Œ -kâ Á Á˝Δ˛ ÁΔ Á Á!•˛B•1å˛=ÔB=ÔB=ÔF1=ÔF1=ÔB=ÔB=ÔF1BBF1=Ô˝B
9Œ9Œ=Ô%))J9Œ9Œ=Ô9Œ=Ô1å®Δ Á ÁΔΔ Á Á!Δ! ÁΔ Á!B!•1å=Ô5≠˛B˛=Ô˛B˝=Ô BF1BB=ÔF1BF1=ÔF1˛B =ÔBB1å-k%)•! cB¸ c Ñ˚Δ Á Á! Á Á˛!)J%))J˛-k)J1å5≠)J1å-k˝1å 5≠˛1å5≠-k˛)J-k1å1å=Ô5≠9Œ5≠5≠9Œ5≠9Œ1å1å-k1å-k1å-k)J˛-k%)-k)J-k%)˛)J%)%))J%)%))J!˚%)!%)%)!˛%) !˛%)$!%)! Á!)J%))J%)!%)%)!!%)! Á%)!%)!!%)%)!•B c cÑ c cNsJRJR5≠!¸)J
Δ Á Á!%)%))J-k1å-k-k)J)J1å˚-k1å-k˛1å-k1å9Œ˛5≠1å1å˛5≠71å1å)J-k1å%))J%)-k5≠1å-k1å)J-k%)1å)J)J%))J%)-k%))J%)%)!!%)%) Á! Á!%) Á!Ñ• cÑ ÁÑΔÑ Á Á!• Á•Δ ÁΔ c˛Ñ cB!ΔΔ ÁÑΔÑ! Á%) cBB cBΔ9ŒF15≠9Œ=Ô9Œ˝=Ô5≠5≠1å)J!!)J1å-k-k1å5≠1å5≠1å5≠1å9Œ˛5≠
-k)J-k%)-k-k5≠B=Ô=ÔB˛=Ô F1=ÔF1B=Ô-k1å1å-k1åF19Œ˛=ÔB-k)J)J5≠=Ô5≠9Œ¨ ÁΔ˛ Á˛Δ$ Á ÁÑBB c)J=Ô9Œ5≠=Ô9ŒBB=Ô9Œ=Ô9Œ9Œ5≠9Œ9Œ=Ô9Œ=Ô9Œ=Ô=ÔBB=Ô5≠%)%) Á c!˛B Ñ˛ c••ΔÑÑ•Δ˙•
Δ•ΔΔ Á Á! Á%)-k-k)J1å)J˙-k1å-k1å1å9Œ˝1å9Œ1å5≠5≠9Œ1å˚5≠1å)J)J%)!%)-k-k)J%)-k%)-k)J-k)J)J%))J)J-k%))J%)%)¸!$%)Δ•ÑΔ Á Á c••ΔÑΔÑÑ•! Á•Ñ••ÑÑ•ΔÑBÑ•• cÑ cΔ•!˛Ñ%)1å9Œ˘=Ô≠5≠-k1å-k-kΔ••Δ%)5≠-k1å-k5≠-k1å5≠5≠1å9Œ9Œ=Ô5≠)J-k-k˛1å5≠=Ô¸BF1BB=ÔB=Ô-k˛1å5≠=Ô9Œ=Ô=ÔB˛-k1å=Ô9Œ9ŒØ Á ÁΔ ÁΔ Á•˛ Á BB!•1å5≠9Œ=Ô9Œ9Œ˛5≠9Œ5≠¸9Œ 5≠=Ô=ÔB=ÔB=Ô1å)J%)Δ c!¸B Ñ c•Ñ• c•Ñ˛• Ѹ•
Ñ••ΔΔ ÁΔ!%)!%)1å1å-k˛)J1å-k˛1å)J-k˚1å 5≠˝1å5≠1å9Œ˚1å-k)J%))J%)! Á¸)J%)-k)J)J˛%) )J˛%) !%) ÁΔ!••ÑΔÑÑB!˛ÑBÑΔ• cΔ•˝Ñ cÑ cÑÑΔÑ! cÑ! c cΔ ÁΔΔ!1åB9Œ=Ô5≠9Œ=ÔB1å5≠-k1å)J˛-k&)J•• Á•Ñ%)1å1å-k-k5≠-k1å1å5≠5≠9Œ5≠9Œ)J-k-k1å)J-k-k5≠9ŒB=ÔF1=ÔBBF19ŒBB˛1å-k9Œ˛=ÔB=Ô9Œ)J-k-k=Ô9Œ9Œ†˛ ÁΔ ÁΔ˛ Á
ΔB!B!9Œ5≠=Ô9Œ=Ô9Œ=Ô5≠5≠˝9Œ1å=Ô9Œ¸=Ô1å%)!!˘B -k9ŒÑ•ΔÑ˝•ÑΔΔ•˚Δ Á Á! Á˛!˛ Á!)J1å-k1å)J-k-k1å-k1å-k5≠1å1å9Œ9Œ5≠5≠1å9Œ˙5≠1å1å5≠1å1å˛-k)J)J%)!%)%)-k˝)J˛%))J%) ÁΔ%)%)!Δ• c c•ΔΔÑ Á!••Δ˛ÑΔ•Ñ)J c!Ñ%) cÑ• c c)J ÁΔ•Ñ cΔB)JÑ˛ c• Á%)9Œ9Œ=Ô5≠1å¸-k 1å)J1å-k1åÑ ÁΔ ÁΔ•!˝1å5≠-k˛5≠9Œ9Œ=Ô5≠%)-k)J-k˛1å-kBF1˛B =Ô=ÔF1BB=Ô1å5≠1å1å=Ô9Œ˛=Ô9Œ)J-k-k9Œ=Ô5≠’Δ ÁΔ Á˛Δ Á Á•!! c-k=ÔB=Ô5≠5≠=Ô¸5≠=Ô5≠9Œ9Œ=Ô9Œ=Ô9Œ1å)J!!Ñ B!˛B5!!•JRcΔ c•ÑÑ•Ñ•ÑÑΔÑΔÑΔ•ΔΔ ÁΔ Á Á! Á%))J-k!! Á! Á%))J1å-k1å)J-k%)1å-k1å)J1å5≠1å5≠5≠˝1å -k˛1å5≠5≠-k-k1å-k1å-k˛%) ! Á!!-k)J)J%))J)J%)%)˛)J ÁΔΔÑÑ• ÁΔÑÑ• c c ÁÑ• cÑÑΔ cΔΔ•Δ Á¸Ñ !Δ!ÑÑΔΔÑ ÁÑBÑÑB cB cÑ)J)J!%)-k)J-k-k1å-k1å˛-kΔ• Á˛Δ• Á1å-k˛1å)9Œ5≠5≠9Œ5≠5≠=Ô9Œ%)1å1å5≠5≠-k)J-k9ŒB=ÔB9Œ=Ô=ÔBB=Ô-k1å-k-k5≠B9Œ9Œ=Ô9Œ)J-k)J9Œ5≠9Œ∂˛ Á˛Δ
ÁΔ! cB! Á9Œ=Ô5≠9Œ˛5≠9Œ5≠9Œ5≠9Œ5≠=Ô9Œ˛=Ô1å)J! ÁÑ!! c˛B c! c•Rîc=Ô!˛•ÑΔ••Ñ•ÑΔ•˝Δ ÁΔ Á Á!!%))J-k-k1å-k-k%)%) Á!%))J)J˛1å-k1å-k1å˛5≠1å1å˝5≠9Œ1å9Œ1å5≠1å5≠)J˝-k˛)J!%)%)!!%)-k)J˝%) !˛ Á• Á Á-k ÁΔ¸Ñ•ÑΔΔ••Δ˛•Δ ÁΔ• ÁÑ ÁÑ Á ÁB cÑΔ• c Á ÁÑÑ˝B
cÑÑΔ•Ñ•!1å-k1å¸-k 1å-k•• ÁΔ ÁΔΔ!5≠1å5≠5≠9Œ1å5≠5≠=Ô5≠9Œ=Ô1å-k)J1å5≠1å1å-k-k5≠˝B =Ô˛B=Ô-k1å)J5≠=Ô=Ô9Œ=Ô9Œ-k)J-k5≠9Œ9ŒÀΔ ÁΔ˛ ÁΔ ÁΔB! c%)=Ô9Œ5≠9Œ5≠1å1å5≠=Ô5≠5≠9Œ=Ô5≠=Ô=Ô1å%)%) Á c˛! c!˛B!Δ%)5≠VµNsÑ•Ñ• c•Ñ•Ñ•Ñ••Ñ• Á•˝Δ Á Á!!)J)J-k)J˝-k)J)J%)˛!)J-k1å)J1å1å9Œ-k5≠5≠1å1å5≠-k5≠1å5≠˛1å-k)J¸-k!)J1å)J-k%)%) Á%) Á%)%))J!Δ•• c cÑ Á•Ñ•!)JÑ cÑΔ c cΔÑÑ˛• ÁΔÑΔ ÁΔÑ••Ñ!ÑB˝ÑB•)J!B•B˛ÑB cÑÑ c Á•Ñ•˛-k )J˝-k1å%)Δ•Δ•!ΔΔ!1å-k1å)J5≠5≠9Œ5≠=Ô9Œ=Ô=Ô9Œ˛-k1å-k-k1å1å5≠˛=Ô9ŒBB=Ô=Ô-k1å1å)J=Ô9Œ=Ô=Ô9Œ)J-k)J5≠9Œ=Ô«•• ÁΔ!Δ Á!Δ!!Ñ5≠9Œ1å˛5≠ 1å9Œ9Œ5≠9Œ5≠=Ô9Œ9Œ1å˛!ÑBB c˚B c)J)J%)NsZ÷9Œ cÑΔÑ•Ñ•ÑΔ••Ñ•• Á˛Δ ÁΔ! Á!!1å)J˙-k1å1å-k1å%)˛!
)J-k1å5≠-k5≠5≠1å5≠1å1å5≠1å5≠˛1å-k-k˛1å-k1å1å˛-k˝)J˛!%)!! ÁÑ cΔ Á Á˛Ñ3ΔB•!• cB•ÑB•ΔÑ•Δ!ΔBΔ••Δ!••Ñ•%) c cÑ cÑΔ! Á••BΔ••!BÑ c•• Á Á• Á˛-k)J1å)J-k-k1å Á•Δ Á• ÁΔ!!-k˛9Œ'1å5≠5≠9Œ5≠9ŒB=Ô9Œ5≠-k-k1å-k1å-k1å9ŒB=ÔB9ŒB=Ô=Ô1å1å-k-kBB9Œ=Ô9Œ1å)J-k5≠9Œ5≠¨Ñ•Ñ•˛Δ! c!! Á5≠9Œ5≠-k1å5≠1å5≠5≠9Œ9Œ5≠5≠1å!%)ΔÑ!˙B ! c•-k%)!5≠RîRî ÁÑ•¸Ñ•Ñ•Ñ˛•˝Δ˛ Á! Á%)%)-k˚)J˚-k1å)J%)%)!)J-k˝1å 5≠˚1å5≠1å1å5≠˛-k 1å-k)J)J1å%))J-k-k)J˛%)ΔΔÑ!ÑÑ˛ cSÑΔ•ÑΔ c c••BBΔÑBΔ cÑÑΔÑΔ cÑΔ ÁÑÑ•!Δ c•B•Ñ ÁÑ!•Ñ•Δ•Δ cB cB! cB Á Á•!1å)J1å)J1å-k1å)J1åΔ•Δ ÁΔ!Δ ÁΔ!-k1å9Œ9Œ5≠5≠=Ô=Ô5≠˛=Ô5≠1å-k1å˛-k1å9ŒB¸=Ô1å-k-k)J9Œ9Œ=Ô9Œ9Œ-k)J)J5≠9Œ9Œ≠ Δ˝Ñ •! ÁB! c)J=Ô5≠9Œ¸5≠ =Ô9Œ9Œ)J%)! Á cB!˘B
Á)J)J!)J%)NsNs=Ô cΔ˛Ñ•Ñ•Ñ˛• Ñ Á•ΔΔ ÁΔ Á Á%) Á%)˛)J-k)J-k)J-k)J)J-k1å-k-k)J-k1å1å-k-k)J%))J)J-k1å-k5≠1å5≠˙1å-k-k1å-k1å-k1å-k-k)J-k)J%))J-k)J• cBÑÑ c˛ Á• c• c c•˝Ñ
BÑ!• cÑ•Ñ•B Á c!•˛Δ•Δ• c•ÑΔ Á cÑ c•Δ! c Á Á ! cB cÑÑ˛ c• Á%)1å-k)J˚-k˝Δ˚ Á!)J1å=Ô9Œ=Ô9Œ9Œ=Ô˛B =Ô5≠-k1å-k1å-k5≠BB=ÔB=ÔB1å1å-k-k5≠=Ô9ŒB9Œ-k-k)J1å=Ô9ŒŸΔ Á¸Ñ,Δ!BÑ5≠9Œ9Œ1å1å5≠9Œ1å=Ô-k)JΔ%)•B!!BB!B!B !•)J%))J%)%)!9ŒNsVµ!Ñ••Ñ•˛Ñ •Ñ•Ñ••Δ• Á• ÁΔ˛ Á%))J%))J)J-k-k˝)J-k-k)J)J1å˛-k1å-k5≠-k%)!%))J-k5≠1å-k5≠1å1å5≠5≠1å-k-k1å-k˛1å-k-k1å1å-k%)-k-k%) Á c cB•ΔΔ Á c cBBÑÑ˛ c,B cÑB cÑÑ cÑ cÑBÑ• c!ÑΔ•ΔÑÑΔ cΔÑ•Ñ cB c•Ñ•BΔÑ)JÑB• cB cB˛Ñ•Δ!˝-k )J-k1å1å-kÑ ÁΔ ÁΔΔ Á! Á%) Á%)-k9Œ9Œ=Ô=Ô9Œ9Œ=Ô9Œ=Ô9Œ9Œ-k1å˛-k=Ô=Ô9Œ9Œ=Ô9Œ5≠)J1å-k5≠9Œ=Ô=Ô9Œ-k-k)J1å9Œ5≠≥ ÁΔ ÁΔÑÑ•BB!%)9Œ=Ô1å1å9Œ5≠1å-kΔ ÁΔ•!!˘B!%))J%)%))J%))J)J%)F1RîB c•Δ•ÑÑ•˝Ñ¸•Δ• ÁΔ˝! -k)J-k%)-k%))J-k)J)J-k1å˛-k )J¸-k
1å1å5≠-k!%)!%)1å5≠5≠9Œ-k5≠˛1å5≠-k1å-k1å-k-k1å-k-k)J)J%)1å1å!B!BÑΔ•Ñ˛Δ c cΔ¸ c B cBÑ c cÑ•ÑÑ•B˛ Á% cÑÑΔ•• cΔ c•Ñ c• cÑÑB cΔΔ!Ñ c c!ÑB cB cÑÑ cΔ-k1å-k1å˝-k1å-k˛Δ˝ Á !!%)!!)J5≠9Œ9Œ=Ô˝9Œ B=Ô1å-k1å-k-k5≠B=Ô˛B 1å˛-k
1å=Ô9Œ9Œ=Ô-k)J)J-k9Œ=Ô¿ ÁΔ Á Á! Á ÁBB•1å)J%)! ÁÑÑBB!B!¸B !! c c!!Rî-k Á)J˛%))J!NsNs=ÔBΔ˝Ñ•ÑÑ•˛Ñ•Ñ Á••ΔΔ Á Á!%)%))J%))J-k)J)J-k)J)J¸-k 1å˝-k¸1å-k1å5≠5≠1å-k)J%)-k1å5≠5≠1å1å-k1å5≠1å5≠˛1å˛-k)J-k•B!Ñ Á˛Δ˝•Ñ cΔB c c˛BW c! c!•B•!!• c c ÁÑ c• ÁÑΔΔ•BÑ Á c•Ñ cB•ÑÑ c!Ñ! ÁÑ!ÑB c cBB!•ÑBB•%))J)J-k-k1å-k1å-k1å)J ÁΔ Á Á!%)%)!%)%))J!1å9Œ9Œ=Ô9Œ9Œ=Ô9Œ=Ô1å1å)J1å1å˝=ÔB9Œ˛-k)J=Ô9Œ=Ô9Œ5≠˛)J9Œ9Œ∫•ΔΔ˛ Á•BBΔΔÑ cB˛! B˛!B!B˛!BΔ!B!=ÔF1Δ!˛%)
)JΔJRNsNs•ÑΔÑB cBÑ c˘ÑΔ•Δ Á ÁΔ%)%))J!%)!-k)J%))J%)-k˛)J˛-k)J)J-k)J1å-k1å-k1å-k1å1å5≠1å1å-k1å%)%))J˛1å -k˛1å¸-k1å-k Á˛ c••Ñ ÁÑΔΔB•BΔ!B cÑ˛B cB!B c! cÑ!!B!Δ• cÑ˛•Ñ c cÑΔ cB cBB• c cB!B cΔB c! c c˛B !Ñ cΔ! cÑ•Δ1å¸-k 1å-k1å1å-k Á! Á! Á%)!)J˛%)1å=Ô5≠5≠=Ô9Œ9ŒB9Œ)J9Œ)J1å-k=ÔB˛=Ô˛-k
%)%) Á Á•ΔÑ• Á)J%)¸)J -k˛)J-k1å5≠1å-k1å5≠˛1å5≠5≠1å5≠5≠˙1å9ŒΔ!˛B -k=ÔB9Œ5≠9ŒBJRNsRîNsJRVµRî^˜Vµ˝RîVµRîVµRîNsRîRîVµRîVµNsNsRîNsF1Ns˝JRNsJRNs˝B=Ô=Ô9Œ9Œ-k9Œ5≠9Œ-k)J%)!!%) Á ÁÑÑ c˛B!B!¸B! cB c!B!B˛!B!BB c!Δ! ÁΔ ÁΔ! Á ÁΔ Á Á=Ô=ÔB=Ô5≠-k5≠5≠1å¸)J5≠5≠1å˝)J˛1å)J%)5≠1åñ •ΔΔ ÁΔΔ ÁΔΔ•ΔΔ• Á=Ô%)Δ ÁΔ ÁΔ=ÔJR1å!ÑB c!BB˝ cÑB c c˝Ñ• Á!Δ ÁΔ! Á!Δ! Á! Á! Á! Á˘!˛%)ΔΔÑ ÁΔ%)!-k¸)J -k¸1å5≠-k1å-k5≠˚1å -k5≠5≠-k5≠9Œ1å5≠)J!˛B 5≠1å Á-k=Ô=Ô9Œ9Œ=Ô9ŒBF1BBNsF1BF1JRNsNsRîRî˛Ns Vµ˛Rî JRRîBJRB=Ô5≠B=ÔB˛=Ô 9Œ9Œ5≠)J1å%)1å1å)J!˛1å )J¸! Á•Ñ cBB!B!B¸!B! c!B¯! B!ÑΔ!Δ ÁΔ ÁΔ¸ Á!B=Ô=Ô˚1å%))J%))J-k5≠-k˛)J%)1å5≠-k%))J-k1å¿ΔΔ Á ÁΔΔ˛ Á˝Δ%)BΔ Á Á!Δ%)BJRÑ cÑÑ c cB cB cB˝ c˛Ñ c•Δ ÁΔ Á Á!˛ Á˛! Á˚! %)˛!%)!! Á%)!)J!%)Δ! Á!!%)-k-k%)-k-k5≠-k1å-k˛1å 5≠˝1å 5≠5≠1å1å5≠5≠9Œ1å5≠1å5≠5≠=Ô c!!B 9Œ!-k Á%)-k9Œ-k-k)J5≠˛1å4=Ô-k9Œ9ŒBBNsRîNsJRRîNsRîNsVµF1RîJRBB=Ô1å9Œ)J-k%))J%)!)J)J!)J%)Δ ÁΔ Á Á•%)%)1å%)-k Á%)! ÁΔÑ cÑ˝B!B!˛B"!BB c!B!B!B!B!BB c c!! Á•Δ Á ÁΔ!Δ!ΔΔ1åB9Œ=Ô-k¸1å%))J%))J1å1å˝)J1å5≠1å)J)J1å1åΩ •˝Δ Á˚Δ
•5≠1åΔ Á ÁΔΔ-kJR5≠BÑÑ˝ cB c¸B cB˛Ñ• Á Á!˛ ÁΔ Á! Á! Á!! ÁΔ! Á! Á!%)! Á!!˛%)!%)!%)!˛%) Á!%)1å-k¸1å-k1å-k-k˝1å&-k1å1å5≠1å5≠1å9Œ1å1å-k1å5≠%) B!!1åΔ! Á! ÁÑ! Á Á%)1å Á)J Á-k)J5≠1åBB˛JR NsNsJRNsF1F1=ÔF1B=Ô5≠1å%)˛!ΔΔ Á!•Δ• Á)J-k!Δ ÁΔ•• Á˛%) ÁΔΔ Á•Ñ c cBB!B!B!B˛!B! c˝B
!B!B!!B Á Á!%)!ΔΔ˛ Á! Á ÁΔΔ5≠=Ô9Œ=Ô˛1å5≠1å-k%))J%)1å-k-k%)%)!)J-k1å%))J1å1åº Á• Á˛Δ Á•˝Δ Á=Ô%)Δ! Á ÁΔ=ÔNs Á c•ÑÑB˙ cB c˛B c•Δ˝ ÁΔ! Á! Á! Á! Á! Á Á! Á Á%) Á!!%)!%)!!%)!˛%) )J)J%))J-k)J-k-k1å1å5≠-k5≠¸1å5≠1å1å5≠5≠˛1å)5≠1å5≠1å5≠1å1å-k1å1åÑ !B5≠!)J1å=Ô9Œ5≠%)Δ c•Ñ Á••Ñ Á)J)J9Œ=ÔBJRF1JRF1JRB˛=Ô˛9Œ-k! Á!ÑBB˛ c
Ñ cÑ cÑΔ%) Á• ÁΔ˛•Δ!! Á ÁΔ••Ñ c cBB!B!˛B!B!B!¸B!BB˛ cÑ%)Δ%)%) ÁΔ˝ Á !˛ Á!=Ô=Ô9Œ5≠1å5≠1å1å5≠)J%)%)-k1å-k%)-k%))J1å-k)J%)-k-k§•ΔΔ Á•˚Δ•)JBΔ˛ Á•%)JRF1˝Ñ˜ c¸B ÑÑΔΔ! Á ÁΔ Á Á! Á!¸ Á! Á! Á! Á˝!
%)!%)!%)!%)%))J%)1å˝-k)J-k-k1å-k5≠¸1å 5≠1å5≠)J5≠-k1å-k5≠-k5≠-k5≠1å5≠1å5≠-k! Ñ-k Á-k=ÔBF1=Ô=Ô1å%)••˛ c"Ñ Á%))J1å1å=Ô=ÔF1BNsBB=Ô=Ô9Œ9Œ5≠1å)J ÁΔ Á c c!!BÑBÑΔ%))J-k˛)J!ΔΔ•Δ•Ñ˝ ÁΔ ÁΔÑB c!B˛! B˛! B˛!˛B!B˛! B cÑΔ)J Á%)!!Δ Á Á!˛ ÁΔ•)J˛=Ô5≠-k1å5≠5≠1å!!%)1å1å!%)!)J1å1å%)%))J1嵕•ΔΔ ÁΔΔ ÁΔΔ ÁÑB1åΔ Á ÁΔ•5≠JR5≠ c˛Ñ˛ cB cB˚ c Ѹ cÑÑ! ÁΔ Á˛!˛ Á˛! Á! Á! Á! Á%) Á)J%)!)J˛%)!)J˚1å˛-k 1å-k1å-k5≠1å1å-k1å-k1å1å5≠˛1å 5≠˝1å5-k1å1å5≠1å-kÑ •5≠%)9Œ=ÔB=ÔB=ÔB5≠9Œ5≠1å)J%) Á ÁΔ%))J1å1å=ÔBJRF1JRB=Ô9Œ5≠1å-k%)!•ΔÑ•Ñ ÁΔ!%))J¸1åŒ5≠5≠-k-k ÁΔ••Δ ÁΔ!!ΔΔ Á• c!B!B!B!B!˛B!B!B!˛B
cÑBÑ!ÑΔ)J!)J%) ÁΔ!˝ Á Δ Á•5≠=Ô=Ô9Œ1å-k5≠1å5≠˛%)1å-k)J%))J)J1å1å˛)J 1å†ΔΔ•• Á Á•˛Δ•)JJR)J• ÁΔ Á•F1Ns%) cÑÑ c cBB cB˛ cB c c¸Ñ B˛ cB•!˚ Á!Δ Á˝! Á Á˛!%) Á¸%)˛)J-k1å-k1å1å-k5≠-k)J-k)J)J-k1å1å-k-k1å5≠˛-k˛1å-k1å5≠¸1å˛-k Á Á5≠%)5≠=Ô5≠9Œ5≠1å%)! Á Á!˛%)!!•• Á-k9ŒF1BJRBNsF15≠1å1å!•˛ cÑ•%)%)˝1å5≠1å5≠5≠9Œ5≠)J-k-k)J!•• cÑ• Á Á!Δ Á Á! cBÙ! B˝!BB!B!••! Á! Á!! ÁΔΔ Á ÁΔ Á˛ΔB9Œ=Ô5≠5≠-k5≠-k)J!!)J1å)J%)%))J-k5≠)J!-k-k´˛Δ • ÁΔΔ! ÁΔΔ5≠B˝ Á
•Δ•Δ•ΔΔ ÁΔ• ÁB5≠•˛ Á •1åF11å cÑÑ c cB cB cB cB c cÑB c cÑ•Δ Á Á•Ñ˝ cÑΔ Á Á!!˛ Á! Á! Á! Á!!%)!!%)-k1å-k)J˛-k1å9Œ-k1å)J5≠1å)J1å-k)J-k)J)J-k1å-k1å-k1å-k1å-k˛1å9Œ-k1å1å-k1å-k5≠-k! 1å9Œ9Œ)J%) cB%)5≠ Á c!Ñ=Ô cB˛ c
Ñ%)!-k-kBNsVµRîRîF1B-k!˛B c c Á%) ÁB ! Á%))J5≠1å-k)J!••!%) Á˝•ÑÑ Á%)!!Δ ÁΔΔB!!B!B!!B!!B! c!B¸!BB• Á˝!˛%)! ÁΔ ÁΔ ÁΔ ÁΔΔ1å9Œ=Ô9Œ-k1å-k1å%)%) Á-k-k˝)J1å-k)J%)-k–Δ•Δ•ΔΔ˛ ÁΔ)JB)JΔ!˛Δ=Ô9Œ)J cÑÑ cB˛ c B˝ cÑ cÑ cÑ•ΔΔ ÁΔ ÁΔ Á•ÑBÑ c•Δ Á! Á Á˛!
Á!!%)!)J)J-k)J1å)J1å-k)J˚1å5≠1å-k˛1å-k1å)J˛-k)J1å-k1å-k-k˛1å5≠-k1å5≠˛1å˛-k<)J Á!5≠F1B9Œ-kB%)Δ! Á!B cÑ! cBBΔΔ c•Δ5≠=ÔRîVµVµZ÷Vµ=Ô%)•BB cBBÑ c c%)1åΔ cÑB! cBÑ ÁΔ! cΔΔ˛•ΔΔ•Δ! Á˛!Δ ÁÑ!!B!!Ñ!BB!B!B!B!B! c!• Á%) Á˛%)" Á%)!%)!ΔΔ! Á! ÁΔΔ!=ÔF19Œ5≠-k5≠1å)J%)!)J1å)J%)%)-k1å1å)J-k)JØ•ΔÑΔ•Δ Á˛Δ5≠=Ô˛Δ Á•%)9ŒBÑ cÑ cB cBB¸ c Ñ˛ c Ñ c•Δ ÁΔ ÁΔ ÁΔ ÁΔÑ˛ c•Ñ˛!˛ Á! Á!˛%)˜-k5≠%)1å-k1å-k˛1å-k1å-k1å˝-k )J-k-k5≠-k1å-k5≠1å5≠¯1å=5≠)J9Œ=ÔJRF1!•B ÁF1F1!Δ !%)Δ9Œ••-k ÁΔΔ9ŒRîZ÷RîRîF19Œ%)Δ!BB! cÑ•-k%)Δ )J5≠-k!1å B! BÑ!!Ñ••˝!%)%)!)J˛! %))J cB!BBΔ cB!B˛! B˛!B!ÑΔ Á Á! Á!!%)!!%)%)Δ Á˛Δ Á ÁΔ•-k9Œ=Ô9Œ-k-k1å-k! Á!-k-k)J)J%)1å-k)J%))J±Δ•Δ•Δ•˛Δ Á=Ô1åΔ Á Á•Δ%)=Ô5≠ cÑÑ c cB cBÑ˛ cÑ cÑ cÑ cÑΔΔ˝ Á Δ¸ ÁÑ•˛Ñ Á Á! ÁΔΔ!)J¸-k )J˛-k1å)J˛-k1å-k˝1å -k¸1å5≠1å-k-k1å˛-k1å-k1å1å5≠-k¸1å&-k1å-k5≠5≠)J9ŒF1B9Œ5≠)J%))JΔ•9Œ!!)J%)%) Á9Œ%)! Á1åB9Œ9ŒF1NsVµJRF1=Ô)J•˛B !˛%) ÁBBB^˜súB! !BÑ c!BB c• Á)J-k˛)J%)%)˝! %)-k Á! c!BBÑ!˛B !BB!!B!B•ΔΔ%)¸! %)˛!%)Δ Á Á!˛ ÁΔΔ˛9Œ5≠5≠)J1å!%)!-k%))J%))J)J-k)J)J%)∂˝Δ••˛Δ%)JR%)• Á ÁΔ Á9ŒB%)BÑ c cB cB cB˛ cB c cÑ c c•˝Δ ÁΔ ÁΔ ÁΔ˝ ÁΔ• c cÑΔ Á Á%)˛)J-k)J-k)J˜-k1å)J˛-k)J1å-k1å˝-k1å1å˝-k )J1å1å5≠-k1å-k9Œ1å1å-k1å-k˛1å%)=ÔNsJRNsNs=Ô=Ô9Œ9Œ5≠=Ô9ŒNs1åB9Œ1å˛-k1å5≠F1B=ÔBRîRîNs9Œ1å%)ΔBBÑ! Á˛!%))J1åBJR^˜)J%) c cÑ ÁΔ c!B c•!)J1å˛5≠-k%)!%) Á%)!%))J˛B !B!ÑBB!B!B˝! c Á•Δ Á%)˝!! Á! Á Á!!Δ Á ÁΔΔ ÁΔ•%)=Ô9Œ9Œ)J-k)J%) Á!)J-k)J)J%))J-k-k!)J≥ ••Δ•ΔΔ ÁΔΔ1åB•˛ ÁΔ%)F1JR˝ÑB cBÑ˛ cÑ cÑ cÑ˛ c ΔΔ Á Á!Δ Á•!Δ˘ Á•• Á!%))J-k)J1å˛-k )J˛-k)J)J˝-k1å-k˛1å-k1å-k˝1å 5≠-k5≠-k5≠1å1å-k-k)J-k-k˛5≠˝1å˛-k#5≠-k)JF1F1NsRîRîBBF1JRF19ŒBF1NsF1JRF1=Ô9ŒBJR9Œ5≠=ÔBNsVµNsF1B9Œ)J!˛Ñ" Á)J!9Œ1å-k=ÔF1RîJR1å9Œ)JB5≠!Ñ•Ñ cΔ• Á)J5≠9Œ1å-k)J1å-k%)!%)!˛%) cÑ˝B! cBB!B!! B! c Á!ΔΔ Á!!%)˝!%)!! ÁΔ ÁΔ˛ ÁΔ•9Œ=Ô9Œ9Œ˛)J!!%)1å˝)J1å)J)J%)Œ ÁΔ••˝Δ•B5≠•Δ Á ÁΔ1åF19Œ! cÑB˙ cB cB cB cB•Δ ÁΔ ÁΔ!Δ ÁΔ Á˛Δ ÁΔ!%)˛)J˛!%)%)-k˝)J-k)J1å)J-k1å˛-k1å)J1å)J-k-k1å1å5≠-k1å-k1å-k1å-k1å-k1å˛-k11å-k-k)J-k1å1å-k1å-k1å-k1å-k)J-kBJRJRRîF1VµF1BF1JRJRNsNsBF1=ÔF1B=Ô9ŒB=ÔB9ŒF1RîVµJRF1B1å! ÁÑ˛•@5≠5≠9ŒJRF1BF1JRRîJRNs9Œ%))J1å1å)J1å1å9Œ1å9Œ=ÔBBF1B=Ô1å5≠)J)J! Á! Á!Δ! c!B!BB!B c!!Δ c!BÑ%) Á!Δ•!%) Á! Á˚!ΔΔ ÁΔ ÁΔ ÁΔ Á=Ô=Ô5≠-k-k)J Á Á%)-k)J)J%)!%)-k%))JΩ %)%) ÁΔΔ•ΔΔ ÁB-k•˛ Á•F1JR! cÑ˛ c Ѹ cÑB¸ c" ÁΔ ÁΔ Á ÁΔ!Δ Á Á! Á!%))J)J-k-k)J-k)J%))J!%)!)J)J-k)J1å-k1å)J¸-k1å-k-k1å-k-k1å1å-k¸1å -k˝1å -k˛1å-k-k1å)J5≠5≠1å)J˛1å-k5≠)J5≠BF1JRJR˛Rî
F1BF1F1NsJRNs=ÔB9Œ9Œ˛=Ô9BB=ÔJRRîNsRîF1=Ô-k%) Á Á•Δ)J!!9Œ9ŒB=ÔBF1NsZ÷Z÷VµNsF1F1BJRJRB5≠=ÔJRJRF1F1=Ô9Œ=Ô1å9Œ1å)J%)!!%))J Á cBB!˝B!!B!ΔΔ!B•!!%)!Δ Á Á%)!%)˙!Δ Á ÁΔ˛ Á•-k9Œ=Ô5≠-k-k! Á%)-k1å)J)J%)%)-k-k%)∫ !˛%)˛!
Δ-k=Ô Á ÁΔ Á•%)F1B˘ cB cB˛ cBB c cÑ ÁΔ ÁΔ˛ ÁΔΔ Á!%)%)˙)J %)˛)J %)!)J!%)%)-k-k)J)J˛-k )J˛-k )J1å)J5≠1å-k-k1å-k1å)J1å˛-k 1å1å-k1å-k-k1å-k1å-k˝1å5≠-k-k1å1å-k)J1åF1BJRNsRîJRRîNsJRB9Œ9ŒB=Ô=Ô9ŒBF1Ns˛F1
9ŒBNsRîVµRîJR5≠5≠! Á˛Δ"%)9ŒB)J5≠=ÔB9Œ=Ô5≠=ÔF1NsNsJRB=Ô9Œ)J1å=ÔJRF1F1JR9Œ1å9Œ5≠9Œ9Œ1å-k!%)˝!B cBB! c˛!B!B c%)!ÑΔ!˝ Á• Á!! Á! Á Á!! Á! ÁΔ ÁΔΔ Á ÁΔΔ˛9Œ
-k-k%)%) Á)J-k-k%)%)!)J)J%)≈%)!˛%)!)J!B5≠• Á!Δ•5≠Ns)J cÑÑ cÑ c cBÑ˝ cB cBÑ c˛Δ ÁΔΔ!!%)˛)J -k˛)J -k¯)J-k%))J%)%)!%)˛-k 1å-k-k1å-k-k5≠1å1å-k-k1å1å˛-k1å5≠1å1å-k-k5≠˛1å5≠-k5≠-k1å5≠1å)J1å-k1å1å9Œ-k5≠)JBBJRF1Ns˚RîXNsJRF1F1JRNsRîJRJRRîNsB=ÔF1RîZ÷VµNsF1B1å!Δ ÁÑ Á Á-kF1F11å9ŒBF19ŒB9Œ5≠)J%)!!•!5≠JRJRRîJRRîBB9Œ9Œ=Ô9Œ9Œ5≠)J)J!%)!)J Á•B cBB cB!B!B c c-kBÑΔ!%) Á Á! Á•˛! Á˛! Á!%)%)Δ Á!˝ ÁΔ-k9Œ9Œ5≠-k%)!!%)5≠-k)J)J%)%)1å%)…!%)!%)!! Á!=Ô)JΔ ÁΔ ÁÑBBΔBÑ˛B cB cB cB˛ cB cBΔ˛!%))J)J%)¸)J
%)%))J)J%))J%))J-k)J%)˝)J-k)J)J%))J%)!%))J-k-k)J-k)J-k-k1å-k5≠)J-k-k1å-k˛1å -k-k5≠1å-k-k1å1å-k1å-k1å˛-k 5≠˛1å-k-k˛1åBF1˛JR Ns˛JR2NsJRNsF1JRJRNsF1NsJRRîF1F19Œ9ŒF1JRNsRîF1JR=Ô)JΔ ÁΔ•Δ Á)J1åJRF1B=ÔBNsF1NsF1JRF1JRBRîVµRîRîVµRîRî˛B=Ô=Ô˛9Œ 1å1å)J%)!!)J• cÑBB˚!BÑΔ)JÑÑ!%) Á! Á Á! ÁΔ! Á˛! Á%) Á˛!Δ Á Á! Á! Á%)1å9Œ9Œ-k-k!Δ%)-k-k)J)J%)!)J)J∑˛%)!)J! Á-kF1Δ˛ Á•!F1=ÔBÑÑ˛ c B˛ c
BÑ cÑÑ•Δ%))J-k)J-k)J-k˝)J%))J)J-k)J-k˝)J -k˛)J-k)J)J-k)J-k)J-k-k)J%)%))J)J-k-k1å-k-k1å-k1å1å-k-k1å1å˛-k1å1å-k1å5≠˝1å-k)J˛1å -k˛1å-k5≠˛1å5≠1å=Ô˛JR NsJRRîJRF1NsVµRîRîNs˛Rî˛NsF1B9Œ=ÔBJRRîRîJRF15≠-kΔΔ!˛Δ)J-k=ÔF1JRF1BF1BF1NsRîRîNsRî˛NsVµNsNsF1JRF1B9ŒB9Œ=Ô5≠1å-k)J!%)%))JΔ cÑ c! c˛!B!BÑ˛ Á c%)˚! ÁΔΔ%)!%)¸!%)! Á Á˛!Δ)J%)-k9Œ=Ô5≠1å%)%) Á-k-k1å%))J%))J)J≈%)%)!! Á! Á5≠5≠• Á ÁΔ•)JJR%)! cÑ c cB˝ÑΔ• ÁΔ!!%)%)-k%))J%))J%))J%))J)J-k%))J%))J%))J%)˝)J -k˛%)-k)J-k)J-k)J˛-k
1å1å-k-k1å1å)J-k1å=ÔNs¸JR?RîNsVµRîNsRîRîVµVµJRNsNsJRF1=Ô5≠B=ÔNsRîF1JRB-k!Δ•Δ!Δ! Á1å9ŒF1F1NsF1JRF1BF1RîF1NsRîRîNsRîJRRîF1JRBF1BB=Ô=Ô5≠5≠1å-k%)˝!Δ c c!!BB˛! B!Ñ Á!Δ c%)%) Á˝!%) ÁΔΔ˚! %)˝! Á!Δ!)J)J!1å9Œ5≠1å-k!!%)1å)J%)%)!!-kª%) Á%)˛!%)B-kÑ Á˛Δ9ŒJRÑ cÑ c Á Á! Á! Á! Á! Á! Á Á˛%))J)J-k%))J)J-k%)˝)J-k%)-k¸)J-k%)-k)J-k)J-k)J-k˛)J1å-k1å-k)J%))J!)J˛-k˛1å˝-k1å5≠)J˛-k1å1å-k-k1å1å)J1å-k˛1å-k5≠1å-k1å5≠-kF1-k˝JRRîNsRîNsRîNsVµVµ˛Z÷ RîVµNsNsJRF1=Ô=Ô9ŒJRNsNsF1F1=Ô-k!!Δ!Δ!Δ%)-k=ÔF1F1NsJRJR˚NsJRJRVµJRNsBNsF1˛JR =Ô˛9Œ 5≠5≠%))J!)J!%)Δ c cB! cBB!B!B•!1å%) c)J!! Á Á˝!Δ! Á!!%) Á˛%)!%)%)˛ Á)J-k-k%)-k9Œ9Œ-k)J! Á!-k1å)J%)%) Á%)ª!)J Á!! Á%)F1˛ Á•Δ ÁB9Œ!Ñ cÑÑ•• Á Á!˝ Á• Á Á%)!)J˛%))J)J%)%)¯)J %)˝)J-k%))J)J-k˙)J-k)J)J-k-k¸)J
1å-k1å-k-k1å-k1å-k-k1å˛-k 1å)J-k-k1å-k1å-k1å1å-k-k˝1å-k%)BRî)JF1JRF1JR˛Ns)RîNsRîVµRîZ÷VµRîVµJRRîJRJRB=Ô5≠BBJRNsNsF15≠1å%) ÁΔ ÁΔΔ!)J1å9ŒBBF1JRJRRîRîVµ˛Rî NsRîF1JRJRNsBJRBF1F1JR=Ô9Œ5≠5≠)J-k! Á!! Á•B cBB!B˛!BB•!1å!Ñ%) Á Á%) Á!!%)!%) Á Á˛!%)!!%)˛! ÁΔ%)%)1å=Ô!%)-k=Ô5≠1å%)%) Á)J-k-k!%) Á%)√˛%)!! Á1å9Œ Á• Á Á•%)JR Á cÑÑ•ΔÑBBÑÑ•Δ! Á˝!)J%))J%))J%)˛)J%)-k%))J)J-k%))J%))J-k-k%)-k)J)J-k˛)J %)˛-k )J˛-k)J1å)J-k˛)J 1å%)1å-k1å-k-k1å1å-k1å-k˛1å -k˛1å-k-k˝1å -k¸1å-k5≠RîNs%)F1F1¸Ns$RîVµVµZ÷NsVµRîVµNsVµNsNsF1B9Œ9ŒBBJRRîNsJR9Œ5≠-k!Δ! Á!!%)1å=Ô=ÔJRNs˛RîNsVµVµRîRîVµRîNsNsRîJRJRF1NsBF1B=Ô=Ô1å1å)J)J!˛ Á!ÑBB cB!!B!BB cΔ%)-k Á•)J Á! Á%)˛!
%)!! Á Á%)!%)%)!%)˛!˛%) -k=Ô9Œ1å!-k9ŒB-k)J˛!-k5≠)J%)! Áø%)!!%)!!5≠1å Á˛Δ •5≠B c cÑB ÁΔ Á Á•¸B c•!˛%))J%))J%)%))J%))J-k)J)J%))J%)%)˜)J%)-k)J-k)J)J-k-k)J-k)J1å1å-k%)1å-k-k)J-k˛)J1å-k1å-k1å1å-k)J-k-k1å-k1å-k1å1å˛-k-1å1å)J-k-k5≠-k1å=ÔJR)J-k=ÔJRF1RîNsJRNsRîRîZ÷NsRîVµVµNsVµNsF1NsF1=Ô9Œ9ŒBJRNsJRJRB=Ô5≠-kΔ!˛•Δ!-k9Œ=ÔF1F1NsRîNsVµRîRîVµRîVµRîJRRîJRJR˛F1JRJRB9Œ9Œ1å1å-k!˝ Á• cB c˛B!!B!BBΔ%)5≠ c!! Á Á!˛ Á! Á%)%)!Δ Á˝!˛ Á
!!%))J=Ô9Œ5≠9Œ)J!9Œ5≠9Œ)J˛!)J-k)J˛%)¥!%)˝!F1)JΔΔ!Δ ÁB5≠BÑ c•! Á Á!Δ! Á• c c˛B!%))J%))J!)J%)˚)J -k˛)J-k%))J)J-k)J-k˙)J
-k-k)J-k-k)J-k)J-k-k)J˚-k)J-k%)˝-k˛1å )J1å-k1å-k1å1å-k1å1å˝-k71å1å-k1å5≠RîNs-k ÁF1F1JRJRRîJRNsRîRîVµRîRîZ÷RîRîNsRîF1JR9Œ=Ô5≠BBJRF1JRF1F19Œ5≠%)!ΔΔÑÑ•!-k9ŒBBJRNsNsRî˚VµRîNsNsJRF1F1BF1=Ô=ÔBB9Œ5≠1å%))J!Ñ˛ Á cBB cBB!B!Ñ• cΔ)J1å!-k˛! Á˛! Á%) Á!%)!%)%)˝! Á%)!!%)9Œ=Ô˛9Œ1å!%)B9Œ5≠ Á!!%)-k1å)J%) Á≥ Á%)˛!%)J=Ô ÁΔ ÁΔΔ!JR Á cÑ c• ÁΔ ÁΔ ÁΔ Á! Á ÁΔÑÑΔ!!%)%))J%))J%))J%)¸)J%))J%)-k¸)J-k%))J%))J-k˛)J-k-k)J˛-k)J1å-k-k)J˛-k)J1å%)˛)J-k1å-k1å˛-k1å-k1å¸-k1å)J1å)J˝1åRîRîB%)%)9ŒF1BJRJRVµJRRîJRVµRîRîNsRîJR˛F1 9Œ=Ô9Œ9Œ5≠F1JRNsJRJRB5≠)J-k Á Á•Ñ c•Δ Á-k9ŒBF1F1JRNsRîNs˝RîJRNsNsF1JRF1JRB˛=Ô 1å9Œ1å-k%)! Á Á• Á• c!˛B c!!BÑ%))J•)JΔÑ-kΔ Á Áˆ!%)!!%)˛!%)!1å5≠˛9Œ5≠9Œ%)!1å9Œ1å%) Á!!)J-k-k%)!•
Δ Á%)!!5≠9Œ• ÁΔΔÑ9ŒB˝Ñ˛ Á Δ˘ Á %)!%) Á ÁΔ Á!!%)˛)J%))J%))J)J%)-k)J)J-k%)-k)J-k-k˚)J-k)J)J˝-k)J1å)J1å˛-k 1å1å-k1å-k)J-k-k)J-k˛1å-k1å-k1å-k1å-k-k˝1å -k˛1å)JNsRîZ÷9ŒÑ!=Ô=ÔF1JRNsJRRîNs˛Rî˝NsF1=Ô5≠=ÔB=Ô9ŒBF1NsNsJRF1B9Œ-k˛%)
Á c Á%)%)Δ Á-k=ÔF1F1JRRîNs˝RîVµNsRîNsJRJRF1=ÔBB=Ô5≠5≠1å1å)J%)! Á˛ΔÑ cBB cBÑ!BB•Δ)JÑ Á!-k)J Á Áı! %)˛!%)!%)!)J9Œ=Ô9Œ=Ô5≠9Œ9Œ1å!)J9Œ=Ô-k! Á! Á-k)J%)%)À ÁΔΔ! Á=Ô-k•Δ ÁΔΔF11åB c c• Á!Δ˝ Á !˛ ÁΔ!˝%) ! Á! Á!!%))J-k%)˛)J%)%))J)J%))J%)-k˛)J-k)J)J%)-k)J-k)J-k)J)J1å-k)J1å-k-k1å1å˛-k1å-k-k1å-k)J-k)J-k-k1å)J-k-k1å-k-k˛1å-k1å5≠-k-k)JBNsRîF1 ÁΔ%)5≠=ÔBNsF1JRF1RîBRîNsJR˛B9Œ5≠˛=Ô9ŒB9ŒBF1RîNsF19Œ5≠)J-k)J)J Á•)J-k%)! c%)1å9ŒBJRJR˚NsRîJRJRBJR=Ô=ÔB9Œ9Œ1å9Œ-k-k)J%)!Δ•Ñ•Ñ c!˛B
!B!B cÑ ÁB %))J%) Á!˝ Á !˛ Á!%) Á!!%)˝!%)%)9Œ9Œ5≠9Œ9Œ=Ô9Œ9Œ5≠%) Á1å5≠-k!! Á Á%)1å%)!ï!%)˛! =Ô%)• ÁΔ•!JR%) cÑÑ•˛ Á Δ˘ Á !˛%))J-k˛%) Á ÁΔ Á!)J)J-k˝)J%)-k%)-k%)-k)J-k˝)J-k)J)J˝-k1å)J˛-k)J-k)J1å-k1å-k5≠˛-k˚)J1å-k1å-k1å-k1å˛-k
1å1å-k1å=ÔNsNsRî-k%)• Á=Ô9Œ˛F1˛JRNsF1F1B=Ô=Ô1å-k1å9ŒB=Ô9ŒB=Ô9ŒNsRîJRBB1å1å˛)J ÁÑ-k-k)J!Ñ c-k-k9Œ=ÔNsF1Ns¸JRNsF1JRF1=Ô5≠9Œ9Œ5≠˛-k)J%)! Á Á•ΔÑ˛ cBB!B!BB cÑ•!!-k)JΔ! Áˆ! %)˛! Á˛!5≠=Ô5≠˙9Œ 1å!-k9Œ1å-k!! Á!)J-k%)´˛! Á)J=Ô˛Δ ÁÑ5≠BÑ cÑ c ÁΔ˛ Á Δ˛ Á Δ Á! Á!)J%))J%))J%))J˛%) !˛ Á
=Ô5≠5≠9Œ=Ô!%)1å9Œ-k%) Á! Á˛)Jª%)%)!!9Œ5≠˝Δ•B5≠BÑ c•˚ Á Δ˝ Á
!!%)%))J%)-k!)J)J%)˝)J%)%)!! Á!!¸)J%)-k˝)J-k-k˛)J-k)J˛-k1å-k-k)J˛-k1å)J5≠1å1å-k1å-k˛1å)J-k˛)J-k-k1å-k1å-k-k˛1å%)BRîF1JR)J-k%) c!5≠9ŒBBF1BJRF1F19Œ9Œ)J! Á-k˛9Œ(B9Œ1å9Œ=ÔBRîNsRîJR=Ô5≠-k!ΔÑÑ Á)J%)%)•Ñ!Δ%)1å1å5≠5≠=ÔBF1BBF1B9ŒB9Œ9Œ˛5≠1å%)-k˛!Δ•Δ•ÑBÑ c˛B!B!B!Ñ cΔ%)%))J•! Á Á˛! Á! Á˛! Á!!)J!%)!)J%)=Ô9Œ5≠=Ô˛9Œ 5≠˛9Œ =Ô-k Á1å9Œ1å)J%)!!%)1å)J∂!!%) Á=Ô)J•ΔΔ•!JR!BÑÑ•˛ Á
Δ ÁΔ ÁΔ ÁΔ Á Á!!˙%))J%)%))J%))J%))J˛! Á Á¸)J%))J%)˚)J˛-k)J-k)J¸-k )J˛-k)J1å-k1å-k1å-k1å)J1å)J)J%))J%)-k)J1å-k-k)J-k˛1å'RîNsVµ-k-k Á%)!Δ1å=Ô=ÔBBF19ŒB5≠9Œ)J Á!1å9Œ=Ô9Œ=Ô=ÔB-k-k=ÔBNsF1BF1=Ô-k!˛ cÑ Á!!•Ñ!! c!-k-k1å1å5≠˛=ÔF1B=Ô5≠5≠9Œ5≠5≠1å˛)J
!%) ÁΔΔ•ÑÑB cB cBB˛!BBÑÑ•Δ Á!ΔΔ ÁΔ! Á ÁΔ Á Á! Á!!)J˝! Á%) Á˛5≠=Ô9Œ9Œ5≠˝9Œ5≠=Ô9Œ!%)5≠9Œ1å˝!%))Jº!%)!%)B Á˛Δ•1åBÑBÑ c ÁΔ ÁΔ ÁΔ!Δ ÁΔ! Á!%)%))J)J%))J%)¸)J %)˛)J %)-k)J%)!! Á!!)J)J-k%)˝)J
-k)J-k)J-k)J-k)J1å-k1å¸-k1å-k-k)J1å)J˛-k )J¸1å˛-k)J)J˝-k 1å-kNsNsVµ5≠)J-kΔÑÑΔ1å˛=Ô0B9ŒB9Œ5≠%)!%)9Œ=ÔB=ÔF1=Ô1å%)1å-k-k=ÔF1F1B=Ô9Œ! cB c c••Δ• cBB! c Á-k1å)J1å1å5≠=Ô=ÔB˛=Ô9Œ9Œ5≠-k1å1å)J%))JΔΔ•Δ••ÑÑBÑ!˛B!B! cÑ Á•Δ!%)• Á Á%) Á˛!
Á! Á%)! Á Á! Á%) Á%) Á1å¸9Œ=Ô9Œ=Ô¸9Œ=Ô)J Á1å5≠1å-k˛!%))J¬!! Á-k=Ô•Δ Á••=Ô9ŒBÑ c•Δ ÁΔ ÁΔ ÁΔ˛ Á Δ˛! %)˛)J%))J)J%)%))J˛%))J%)-k%))J%))J%)%) Á! Á!%))J)J%)-k-k˝)J-k-k)J-k˛)J-k)J-k-k1å-k1å-k1å)J1å-k1å)J-k)J˛-k 1å˝-k˛)J-k-k)JJRRîRîF1)J-k-k•• c Á-k9Œ˛=ÔF19Œ1å-k%))J1å9Œ5≠5≠JR=Ô=ÔB! c c)J˛9Œ1å5≠%) c!B˛!B ˛! !ÑΔ Á)J˝1å5≠=Ô9Œ=Ô5≠=Ô˝1å -k)J)J%)!!Δ•ÑÑ cÑ˛ cB!B˝!
cÑ• Á Á-k• ÁΔ ÁΔ˝ Á !˛ Á"! Á! Á! Á!!%)9Œ=Ô5≠9Œ5≠9Œ9Œ5≠9Œ9Œ5≠9Œ5≠9Œ5≠9Œ)J=Ô1å5≠-k)J Á!!-kò%)%)!5≠1å•˛Δ ÁF1! cÑ cΔ! ÁΔ¯ Á!)J)J%))J˝%))J)J%)¸)J%))J%)˛)J˛%)! Á%)!%)%))J)J-k˛)J˙-k)J1å)J-k-k5≠1å˛-k)J-k)J1å)J1å˛-k1å-k)J)J-k¸)J9ŒRîNsNs1å˛-k"•Δ c Á1å5≠5≠=Ô=Ô9Œ=Ô9Œ-k-k1å5≠%)1åBB1å9Œ9Œ!Ñ cB-k5≠-k5≠%)ÑBB¯!BB c˛!-k1å-k-k1å5≠9Œ5≠9Œ1å5≠%)5≠%))J-k)J%)ΔΔÑÑΔ c cÑ˛ c!B!B˛!BÑ• Á)J¸ Á˛! Á%) Á%) Á!!%)!! Á! Á Á5≠9Œ9Œ=Ô5≠9Œ=Ô=Ô¸9Œ=Ô9Œ9Œ5≠JR˛5≠-k-k%) Á!)JØ Á%)!B!˛Δ•%)F1•B c c!˛Δ Á ÁΔΔ ÁΔΔ!!%))J%))J˛%) )J˝%))J%))J)J˛%))J%))J%)-k˛)J%) Á%)! Á!%))J˛-k%)-k˛)J -k˝)J˚-k5≠-k-k1å¸)J4-k)J-k)J1å-k1å-k-k)J)JNsRîRî5≠)J-k1å)JΔ c!!-k1å1å=Ô=Ô9Œ1å)J1å-k)J%))J)JB1å-kB-k ÁÑÑ c• Á Á•ÑBB˜! B cB Á)J1å!-k-k)J˛-k5≠-k5≠-k-k)J)J-k!!%)-kΔÑBÑÑ cBBÑ c˛B¸! cÑ••Ñ Á!! Á ÁΔ Á ÁΔ! Á!Δ! Á Á%) Á!!-k=Ô1å¸5≠9Œ9Œ5≠5≠=Ô9Œ9Œ=Ô5≠BBΔ)J=Ô1å-k%)! Á%)≥ %)!)JB ÁΔ ÁΔ•1åBBÑ c• Á ÁΔ ÁΔ Á Á!Δ Á Á!!%)%))J)J˛%))J-k%)˛)J %)˛)J%))J%)˝)J%)-k-k)J)J%)%)˝!%))J)J¸-k)J)J-k-k)J-k-k˛1å -k1å-k1å-k1å1å-k-k1å¸-k 1å˛-k)JBVµRîB-k1å-k)J%)Ñ c cΔ Á)J5≠9Œ=Ô9Œ˛1å-k!%)%)1å)J1å-kB ÁÑÑ c Á ÁΔÑ!!B˛!B!B!¸B cÑΔ%)-k1å%)1å-k˛)J -k˛1å-k)J%)%)-k)J)J! Á!• c cΔB c˝B !˛B!BB˛ c˛ Á˛! Á! Á!! Á Á¸! Á!)J9Œ9Œ5≠5≠9Œ5≠=Ô9Œ=Ô9Œ9Œ5≠˛9Œ 5≠BJR1å c•9Œ5≠)J-k!!%)À!!-k=Ô•˛Δ•=Ô)J˛ c• Á˛Δ
ÁΔΔ ÁΔΔ ÁΔ%)!)J˛%))J%))J%))J!)J%))J)J%))J)J%))J%))J%)˛)J%)-k)J-k)J%)!%) Á!!%))J-k-k)J)J-k)J-k-k)J)J¸-k 1å˛-k1å-k-k1å)J-k-k)J)J-k-k)J-k%)5≠RîNsNs)J˛1å%) Á!BBÑ•-k˛5≠9Œ1å-k-k Á%) Á! Á1å)J=Ô%)Δ cBΔ!!ÑÑ c˝!B c!B! c˛BÑ c• Á Á5≠!!-k!)J!-k)J-k-k)J)J%))J%)5≠1å˛ Á Δ!ÑBB cBB cB!!˚B
•Δ!Δ Á Á! Á! Á!˛ Á
! Á! Á! Á!!5≠5≠9Œ9Œ5≠5≠˛9Œ5≠9Œ9Œ=Ô5≠=Ô9Œ5≠NsRîΔ cÑ9Œ5≠-k)J)J Á!¨)J!9Œ1åΔΔ ÁΔ ÁF1 Á cÑÑΔ Á ÁΔ˙ Á˛!-k%)%))J)J%))J%)˛)J%))J%)˛)J˛%)˛)J %)˛)J%))J-k)J)J-k%)%)!%)!!)J1å)J-k)J-k)J-k-k1å-k1å1å˝-k1å-k)J1å1å)J1å-k1å-k1å-k-k)J)J1åRîNsRî1å˛-k)J-k Á˝B"%)!)J9Œ9Œ=Ô1å)JΔ!ΔΔ!!1å9Œ-kÑ Á c• Á%)B%)•!B!B c!Ñ!•˛BÑBB cΔ c Á Á)J)J Á%))J%))J%)˛-k)J-k)J!9Œ-k!1å˛ÑΔ!ÑB!˚B!B!BB c cΔ!˝ Á !˙ Á!!˝ Á1å9Œ˛5≠9Œ9Œ5≠=Ô9Œ=Ô9ŒB˝9Œ BRî=ÔÑB-kB9Œ1å)J)J%)Δ∏ !!B)J• ÁΔΔ%)B˛ cÑ Á˚Δ ÁΔ ÁΔ Á Á˝%))J%))J%))J!)J%))J)J%))J%)%))J%)˛)J %)¸)J %)˛)J %)˛)J˛! %)!)J)J-k)J-k)J-k)J˝-k 1å˙-k1å-k-k)J1å%)˛-k6%)F1NsRî=Ô-k)J1å-k1å-k)JB c! c Á Á5≠1å9Œ=Ô%)Δ%)••BΔ)JΔ-k• Á c c%)• cΔΔ!•!BÑ!ÑBÑ!ÑB c!˝B*•Δ! c1å Á! Á)J)J•Δ%))J)J%))J-k5≠9Œ-kÑ)JBÑ!•!B c c!B!B!B c c!BB•˛ Á !¸ Á ! Á! Á!Δ!Δ! Á%)5≠1å˝5≠9Œ5≠5≠9Œ5≠BF1B5≠=Ô9ŒNsNsΔ!•F11å1å5≠1å-k!!π %)%)B Á ÁΔ Á•9Œ5≠˛ c• Á!˛ Á Δ˛ Á Δ ÁΔ!%))J%))J)J%)%)-k%)˛)J˛%)˛)J%))J%))J%)˛)J %)˝)J -k˛)J-k-k)J˚%))J-k1å˝-k5≠-k1å-k-k1å˚-k 1å˛-kH1å)J-k)J1åRîRîJR)J-k1å1å5≠)J5≠!Ñ!BB•)J%)1åB)J%)Δ•Ñ cB!B)J ÁΔ Á•ΔB• c!!Δ cBBÑΔΔBÑΔ c c•BÑB!B c c)J••)J%) Á• Á˛Δ )J-k1å-k!5≠B-k%) c•BB cÑB c cB!B!!B cBB c•Δ˛ ÁΔ ÁΔ!¸ Á
!Δ! Á! Á%)9Œ9Œ5≠9Œ¸5≠9Œ9ŒBBF1F19Œ5≠F1Rî=ÔB c5≠F1Δ1å9Œ-k-k)J Á¬&!)J9ŒΔ ÁΔ••F1)JBÑ c ÁΔ Á•Δ ÁΔ ÁΔ ÁΔ Á Á!%)%))J!)J%))J%))J%))J%)˛)J%)%))J%)%))J%)-k˝)J %)˛)J%)-k¸)J-k)J%)%)˛!%))J-k1å)J˛-k)J-k-k1å1å-k)J˛-kX%))J-k-k)J-k-k)JBRîNs-k-k5≠-k1å-k)J Á5≠B!B cÑ Á Á5≠=Ô!Δ•ΔBBΔ cÑ%)Ñ)JÑΔ•B• Á ÁΔB c c! ÁÑ• c c Á cÑB c c!BB c!•ÑÑ Á Á•• c•• Á Á1å9Œ)J)J!1å1å Á˛ c˝B!!BB˝!BB c cΔ˛ ÁΔ!Δ ÁΔ˜ Á!1å9Œ1å9Œ˛1å5≠5≠9Œ5≠=Ô=ÔBF1B=Ô=ÔJRNsÑ c ÁNs%)•%)5≠-k)J)J!À%)5≠9ŒΔ ÁΔΔ!JR Á c cÑÑ•Δ˝ ÁΔ Á ÁΔ Á!!%))J%))J%))J%)%)˚)J%))J)J%))J)J%))J%))J%))J)J-k)J-k-k)J)J-k˛)J -k˛)J-k)J)J˝%) )J1å-k-k1å1å-k1å-k-k1å1å˛-k
1å-k-k)J-k-k%)=ÔRîRî=Ô˛-k;1å-k1å)J9Œ9Œ=Ô cBBÑB%)1å!-k)J!ÑBÑ•B! c• Á!)JΔ• Á ÁB cΔ•!Δ)J Á ÁΔ•ΔB cB c Á!BB•B!•!Ñ c˛ÑBÑÑ Á-k1å)J1å Á-k%) Á• cѸB !B!B!BB c!!Δ•Δ¸ Á!!˛ Á !˛ Á#! Á Á-k9Œ5≠5≠1å5≠=Ô9Œ5≠5≠9Œ9Œ=ÔBJRBF1F1BZ÷5≠• c9ŒVµΔΔ)J9Œ5≠-k-k!Œ Á9Œ-k˛ΔÑ1åB c cÑÑΔ c cBÑ• ÁΔ˝ Á!)J%)!%)%))J!)J˛%))J%))J!-k)J%)%)˛)J˝%))J)J%))J)J%)˙)J
-k)J)J-k-k)J-k!%)%))J!-k)J˛-k1å1å-k1å-k-k)J˛-kb)J-k-k)J1åNsJRNs%)-k-k5≠-k5≠1å1å5≠F1-k!!B!Δ)J Á!%) Á c! c c!•!Ñ!ΔB!Ñ cÑÑBÑÑ!ÑF1F1)JΔÑ•ÑΔ! c•• c cBB! cB!Ñ c cÑÑ cÑ!)J-k%))J• Á!Ñ• c cB!B!!B!B!˛B c cB˛ Á Δ ÁΔ Á Á!Δ Á Á!˝ Á
Δ Á!9Œ5≠5≠1å5≠5≠1å5≠˛9Œ=ÔF1F1BF1F1JRNsNs ÁÑΔJR=Ô!Δ5≠9Œ1å1å-k%)ƒ$!B%)Δ ÁΔΔ9Œ9Œ!Ñ cΔ Á!Δ• cBBÑÑ Á Á!!%))J)J%))J%))J%)-k%)%)˝)J %)˛)J%))J%))J%))J)J%)˛)J -k˛)J-k%)-k%))J)J˛-k)J-k)J1å)J)J˝%)-k1å-k˝1å˛-k1å)J˝-k3%)F1NsRî1å-k-k1å-k1å)J-kBF1B%)B! ÑΔ!!-k)J-kÑBB cÑ•Δ•!Δ•! cÑB cBÑ!!•1å1å)J cB˛Ñ BBΔBB•Ñ!B!B!!˝B•BB Á Á)J%)1åΔÑ•• c cB c!˛B !!B!!BB•BB•!˛ Á !¸ Á! Á!¸ Á!1å5≠5≠9Œ1å5≠9Œ5≠9Œ1å9Œ9ŒF1BF1F1JRF1JRRî9ŒÑÑ1åRî-k-k%)B9Œ5≠1å-k)J¿%)B¸ΔJR)J! c cΔ Á˛Δ Á•Ñ! cBÑ Á%))J%)%))J˛%))J%))J%)%))J)J%))J)J%)%))J%))J%)˛)J%)-k˛)J-k%)%))J)J%))J)J-k)J%)-k)J-k-k)J1å)J-k˝%))J1å-k1å-k1å-k-k)J-k)J-k)J1å)J5≠JRNs=Ô%))J˛-k41å1å5≠JRNsBBB cÑB••%)•1å!•B)JB5≠9Œ9Œ!%)Ñ)JÑ cBB!B! !ÑΔ ÁΔΔ c!B c Δ!BΔB˝!B!B c c!B! cÑ•Δ!•!Ñ c c˛B cB!B!!B!!˛B cB!˝Δ˛ Á Δ˚ Á!Δ ÁΔ¸5≠
1å9Œ5≠9Œ5≠9Œ9Œ=ÔBF1B˝F1Rî!ÑÑNs9Œ)J)J=Ô=ÔB1å5≠-k%)√5≠=Ô•Δ Á•%)JR• cÑ c ÁΔΔ˛ Á !Δ ÁÑ c!BΔ!!)J%))J˛%))J%))J˛%)-k%))J%)¸)J %)˝)J %)˛)J -k˛)J-k)J-k)J)J˛-kF)J)J1å)J5≠-k1å)J)J%))J)J-k-k1å-k1å-k-k1å-k-k1å-k-kJRRîNs)J-k-k)J1å1å-k1åNsNs^˜5≠Δ! cBB cÑ!)J%))J•1åÑ9ŒJRRîF1F1=Ô Á)JΔΔ c cÑ c c-kJR˛BF19Œ-k! cB c˛B•B•!BB cBB!Ñ!ÑB cB c cΔ ÁΔ c Á˚B !B!B!B!B! c˝B!•˛ Á!Δ˝ Á Δ! Á Á! Á-k5≠=Ô1å¸5≠1å=Ô5≠=ÔBF1F1JRF1JRJRRîF1ÑB5≠Rî-k)J5≠F1=ÔB=Ô5≠-k1åµ5≠1åÑΔΔ•1åJR! c c•Δ ÁΔ ÁΔ¸ Á Δ˛ Á˛Δ Á!%))J)J!)J%))J%)%)!)J˝%) )J˚%))J%))J%))J%)˛)J %)Û)J-k-k1å)J)J%)˛)J˝-k>)J-k)J)JBNsNs5≠!-k1å1å-k-k%)BNsVµF1 Á%)•! cBÑ cÑ!!%))JΔ)J9ŒNsJRRîNsNs9Œ=Ô1å9Œ1å1å9ŒJRJRZ÷RîF1NsF1F1BB)J cΔ!Ñ!˛ c2BB! cBÑBÑB cÑBB c c• cΔ•Ñ• cBB!B cB!B!B!BB! cBÑ!B c! ÁΔ ÁΔ ÁΔ ÁΔ˝ Á!Δ!5≠1å˛5≠ 9Œ5≠9Œ5≠5≠-k9Œ=ÔF1BBF1BBNsRî%)BÑNs=Ô)J)JJRNs=ÔB=Ô9Œ1å)J∏JR%)˝Δ B5≠B cÑ• ÁΔ ÁΔ ÁΔ˛ Á Δ Á!%))J%)! ÁΔΔ Á!¸%))J%)%)˛)J%)%))J)J%)%)˛)J %)˙)J-k-k˝)J
-k-k)J-k)J-k)J-k-k1å)J˛-k1å-k-k1å)J1å˛-k
1å-k)J5≠RîNsJR%))J-k1å˛-k =ÔRîRîVµ! Á-k ÁÑ!˛BÑΔ•)J%))J1å5≠BNsJRRîJRNs=ÔF1F1JRF1JRNs˛Vµ˛Z÷^˜VµJRF1B5≠1å!Δ˛ cB!Ñ•Ñ Á! ÁÑ cÑ• cÑ••ΔΔ ÁΔÑ˝B!Ñ!B!B!˛B!BÑ•B c• ÁΔ! Á! Á ÁΔ!˚ Á 1å9Œ5≠1å1å5≠1å5≠1å5≠˛9ŒF1F1BF1BF1JRNsF1 c c1åRî-k)J5≠NsJRF1=ÔB9Œ1å)Jº B˝Δ
B ÑΔΔÑ!1å!• Á ÁΔΔ¸ Á•-k5≠˝1å 5≠1å5≠1å1å-k5≠=ÔB=Ô˝BF1JRNs!Ñ cJR=Ô-k%)BF1F1BJRJRNs5≠Δ)J5≠Æ •Δ Á•!F1 Á cÑÑ˚Δ ÁΔ Á• Á!!%)!˛%))J%))J%))J˛%))J%))J˛%))J%)!!˛ Á!%))J)J˝%)¯)J -k)J-k-k)J)J-k)J-k)J˝-k˛1å˚-k 1åNsNsJR)J-k-k)J)J-k)J1å˛Rî %)!)J!! Á%)-k Á c!!˛B!B cÑ%) Á)J%)!! Á! Á! Á!! Á•ΔΔ• Á ÁÑ! Á˛Δ)J Á%)!•˝ Á•)J)J•!Δ Á c• Á Á!!Ñ• c˛B!B˛!B!B˛!B!BÑ•ΔB Á5≠-k•ΔΔ Á Á˛Δ ÁΔ%)5≠5≠1å5≠5≠1å1å9Œ1å5≠-k5≠9ŒBBF1˛BF1JRNsBÑB1åRî5≠%)1åNsF1JRNsF1RîJR!•)J9Œµ •˛Δ-kBÑ c c•Δ•˛Δ Á•˛Δ Á!!)J%)!!˛%)!)J!)J!%)%))J%))J!%)%))J!)J!! ÁΔ Á!!%))J˝%))J!˛)J%))J%)-k%))J)J-k)J)J%)-k)J-k)J˚-k1å-k)J%)F1JRJR1å)J)J-k)J-k)J-kF1F1Rî9ŒΔ¸!%)-k%))JÑ!B¸!BÑΔ!ΔΔÑ•!)J-k! Á••˛Ñ c˛Ñ B Á••! Á ÁΔΔ ÁΔ!Δ˛• Á%)•ÑÑ• cΔÑ•ΔÑÑB c˛!B!!B!B˛! B˛!•Ñ! c-k-k9Œ¸Δ ÁΔ Á• Á1å5≠-k¸1å -k˛1å5≠=Ô=ÔB=Ô˝BJRRî!!•JRB)J)JBJRBF1F1JRF11å%)Δ9Œ5≠√˛Δ•9Œ9Œ˛ c •˝Δ ÁΔ ÁΔΔ Á Á!%)%))J%))J˛%) )J˛%) )J˛%))J)J%)!¸)J
%))J!! Á!Δ%)%))J%)˝)J%)-k%))J-k˛)J -k˛)J.-k)J-k)J-k%)1å-k1å)J-k-k1å)J9ŒJRF19Œ%)-k-k)J-k)J)J=ÔJRNsJR! Á!! Á Á)J)J1å-k! ÁÑÑ!B!!˛B cΔÑÑ•! Á!)J Á Á•˛B' cB••!ÑÑ ÁÑ!Ñ ÁΔΔÑΔ•Δ!Ñ cÑ Á Á cB• cÑ cÑ c cBBÑ!B!B˛! B˛!˛B
!B•BÑ%)-k-k1å-kΔ¸ ÁΔ Á-k9Œ1å1å-k1å1å5≠1å5≠1å1å5≠=Ô˝B=ÔF1BJRNsJRB c1åRî-k)J1åJRF1F1BJRNs5≠-k1å1åB5≠ß•Δ• ÁB-k!Ñ c•ΔΔ•Δ•˝Δ Á Á!%)%)!˛%)!%)!!˚%) !˘%))J%))J%)%) Á!Δ Á Á%)%))J%))J%)¯)J-k)J)J-k)J)J¸-k1å-k-k%)-kJRNsB)J!)J)J-k)J)J-kNsJRRî˝%) ! Á)J)J-k%)!1åÑ Á!B˝! Ñ c•Ñ Á•ΔÑ Á•Ñ c˝ÑBBÑ ÑB Á cB c! ÁÑ•ΔÑ Á c Á• c˛Ñ
c!BBÑ c cB cBB˙! B˝!3B!!B cB!Δ!-k)J1å5≠ Á ÁΔ• ÁΔ•!5≠-k1å-k1å-k1å-k1å-k1å-k9Œ9Œ=Ô=ÔBBF1=ÔF1F1Rî Á cÑJR9Œ)J%)B˝F1JR5≠)J-k-kF1=Ô5≠∏
ΔΔ•%)F1!B cÑΔ ÁΔΔ•˚Δ˘%) )J˛%) )J)J%)%))J%)%))J)J%))J%))J˛%))J%)%))J)J%)%)! Á Á!!-k%)-k%)˛)J %)˛)J%))J-k)J)J-k-k)J%)-k1å-k1å1å-k-k9ŒRîRî5≠%)-k¸)JJRNsRî9Œ!%)˛! Á-k)J)J-k-k)J%)B ÁBB!B!˛B ! c• ÁÑ ÁΔΔ•Δ˛ cB c cB c• cÑ ÁÑ• cÑ c cÑ•• c˛•˝B cBBÑB c c˝B˝! BB!B!B!B!B cÑ!Δ!)J%)-k-k1å%)ΔΔ ÁΔΔ!5≠1å5≠˛1å 5≠1å1å-k1å1å9Œ9Œ=Ô=ÔB=Ô˛BF1NsBÑ c-kNs1å)J1åJRF1BF1JR=Ô)J-k)JJRF1=Ô•∏%ΔΔÑ)JBÑB cÑΔΔ Á•ΔΔ Á•ΔΔ Á Á%)!%)!%)!)J!%)!)J!!)J%)%))J˛%))J!%)%))J%))J˝%)
!)J%))J!! Á!Δ!%)˛)J%))J%)¸)J-k)J)J-k)J˛-k )J˝-kNsJRF1!-k)J%)-k)J%)BJRRîF1Δ!%)!! Á˛)J-k)J-k Á Á-k cÑ˛!B!B Ñ cÑ cΔ•!•Δ•Ñ•B˛ c
B• c c• cÑ••Ñ•¸ cBBÑ c cB c!B˛!˛B!B!B˛!B!B¸! B!B ÑΔ%)%)!%)˛-k
)J)J%))J%))J!)J%))J%))J%))J˛%)¸)J%))J%)˚)J%)%)-k)J˛%) )J-k)J-k)J5≠RîRî-k)J%)-k)J)J%)5≠JRJRNs%) Á! Á%) Á!)J!ΔΔ¸ Á !˛ Á!!%)-k1åΔ c!B!B!BB c˛Ñ c!%)! ÁÑ!!B cBB˛Ñ B cB cB!!B!B!B˛! B¸!B!B˙!B!B! cBB! c!B c• Á•˛!-k1å)J5≠1å-k1å-k5≠-k1å-k-k1å1å9Œ=Ô9Œ˙=Ô BJRNs Á =ÔF1)J)JBJR5≠˛)J =ÔF1F1Ns=ÔÑ cB=ÔNs=Ô5≠ò• Á=ÔΔ˛ cΔ•ΔΔ˝•ΔΔ! Á%) Á ÁΔ••ΔΔ ÁΔ! Á%)!)J!)J!)J˝%) !˚%) )J˝%))J%)%))J¸%) )J˛%)˛)J%)-k)J-k%)-k)J-k%)-k)J)JJRNs1å)J%)˛)J !)JF1JRNs9Œ•! Á! Á!˚)J%)! Á ÁΔΔÑΔ•Δ••)J%))J !!BB! c˛!Ñ c Á•Δ Á cÑ• BB c cÑBB!ÑB˝! B˜! Û!BB˛!BÑ! c cÑÑ! Á)J)J5≠%)=Ô9Œ-k1å-k-k1å˛-k&1å5≠=Ô9Œ=Ô9Œ=Ô9Œ=Ô9Œ=Ô=ÔF1F1=Ô !Rî1å%)1åJR1å%))J-kF1F1BNs1åB cB5≠Ns=Ô5≠)J∂Δ Á9Œ˛ c
•ΔΔ•ΔΔ Á•Δ• Á Á%)!˛%)!! ÁΔ•˝Δ Á Á)J%))J¸%) )J˛%))J%))J!%))J%))J)J%)-k%))J%)-k˛)J%))J-k%))J)J-k%)-k¸)J1å)J)J5≠RîJR-k%))J%))J-k%)=ÔNsJRJRΔ!! Á Á!!-k˛)J1å%)-k)J1å)J-k%)%)˛!-k)J ÁΔ Á•˛B !˛B!B c c•Ñ˛Δ•ÑÑ!BBÑBB! c!B!B!B!B!B¸!B!B¸!B!B!B!B! c c!!B c•!%)!˛ c !!Ñ1å-k5≠BB-k-k˛1å˛-k5≠9Œ9Œ=Ô=ÔB˚=Ô BNs Á F1F1)J)J=Ô1å%))J5≠˛F1
JR)J! cB1åRî=Ô9Œ-k1åz•)J-kB c cÑΔ¸•Δ•ΔΔ˝!%)!)J˛%) ! Á ÁΔΔ• ÁΔ Á!˝%))J!˝%) )J˙%))J%))J%))J%))J˛%)-k!)J%))J%))J%)˙)J-kRîNs9Œ!˛)J%))J)JJRF1Rî%)Δ˛! Á!-k%))J%)˝)J-k-k˝)J
-k)J-k%))J)J%) Á ÁÑB˛! B˛!BBÑÑΔ˛ c BB!!Ñ B!B ¸B˛! BÏ!BB cÑÑ c•Δ1åΔB cB cÑ1åF15≠-k1åJR9Œ)J˙-k9Œ9Œ=Ô5≠¸9Œ =Ô9ŒBJRB! ÁNs-k)J)J-k!)J5≠F1F1Ns=ÔΔ!BB1åRîB9Œ1å%)1å∞ Δ1å)JB c c•ΔΔ•ΔΔ˛•Δ Á!!%)%)!¯%)! Á ÁΔΔ Á Á!!)J)J%)%))J%))J%))J˛%) )J˛%))J%))J˛%)
!!-k ÁF11å-kB=Ô)J1å˛-k1å-k5≠˛9Œ =Ô˛9Œ =Ô=Ô9Œ=ÔF1F1-k BB%))J-k%)-kF1JRJRNs1å cBBÑ=ÔNsF19Œ5≠%)1å1åå•9Œ!BBÑ˛• Δ•Δ•Δ•Δ Á Á!%)!˛%)!%)%)!%)%)!%)%)!%) ÁΔ Á• ÁΔ Á!)J!˚%))J!)J!%)%)˛)J˙%))J%))J%)˝)J%)%)-k)J-kNsRî5≠%))J)J%))J!-k˛JR˝Δ ÁΔ%))J)J%)˝)J%))J1å%)¸)J-k)J¸%)-k• ÁBB ˛!BB! c c˛B !˛B˛!B!!BB Ó! !!B!B!˝B cB Á Á-k Á cBΔ-k!-k=ÔΔ c9Œ=Ô)J9Œ-k)J¸-k(1å5≠=Ô5≠9Œ9Œ=Ô5≠9Œ5≠9Œ5≠=ÔF1JRB ÁJR5≠%))J!1åJRF1JRNsΔB c!ÑF1F1B9Œ9Œ)J1å1å5≠ô Á=Ô•BÑ c˛Δ•Δ•˛Δ Á Á¸!%)!˚%))J!˚%)! Á ÁΔ Á Á%)!-k˛%) )J˝%))J)J%)%))J%)¯)J %)%)-k)J%))J-k%)%)JRNsJR%)˝)J%)%)JRNsRî)JΔ! Á˛!)J)J%)˚)J-k)J1å)J)J-k˛)J!%)-k)J)J%))J Á)J•Δ c c!B!B!B! cB!B!!B!!B c! c!B˛! B˛! B˙! B˛! B˛!B!B! cBB˝ cÑ)J%)•˛ c%)Ñ9ŒBNs!B=Ô=Ô1å1åB=Ô-k-k1å1å5≠˛9Œ 5≠˝9Œ =Ô9Œ9ŒBNs1å 5≠F1!%))JBNsNsF15≠ cB c c%)JRF1F15≠9Œ5≠9Œ1å1å5≠â Á=Ô˛ c•Δ•Δ˝•Δ•Δ Á!!%)!%)!!%)%)!%)!%)!˛%) !˝%))J!! ÁΔΔ Á Á!%))J!%)%))J%))J!)J!˛%)!%)%))J%))J)J˝%) )J-k)J)J%)1åNsJR-k!˛)J%)!5≠JRJR=ÔΔ ÁΔ ÁΔΔ!)J%)˛)J%)-k)J%))J)J%)˛)J %)˛)J !)J%))J%)%)!Δ!•˛B˝! B¸!B!B! c„!!B cBB c cB cÑ•Δ-k%)Ñ cB Δ!B!!1å!)J=Ô9Œ9Œ=Ô9Œ-k-k1å=Ô˛5≠˚9Œ5≠BF1JR••Ns1å-k5≠F1JRF11å• cBΔ9ŒJRF1B5≠5≠˛9Œ1å1å5≠û%)5≠! c c•ΔΔ••Δ•Δ•ΔΔ!!%)!˛%) !˝%)!!%)%)!%))J%)%)!%)!%))J)J%)!Δ Á Á!!)J%))J¸%))J%)%))J%)%)ı)J-k%)JRNsB%))J%))J%))J)JJRJRNs!Δ˝ Á!)J)J-k)J)J%)-k%))J)J-k)J-k%)-k%)˛)J%))J)J-k%))J!%)! ÁΔΔ c cBB˛!B!¸B¸! B˛!BB!!B¸!B!B!B!B!B˛!˝B˛ c˛Ñ˛Δ!•Ñ• c• cÑ%) Á9ŒÑ Á=Ô5≠˛=ÔB5≠1å=Ô5≠9Œ5≠9Œ=Ô¸9Œ5≠F1JRB 5≠F1BF1JRRî9ŒÑ cBB c1åJRJRB=Ô5≠5≠9Œ˛=Ô5≠1å5≠•-k)J! cB•ΔΔ•Δ•Δ•ΔΔ Á Á%) Á)J˛! %)˝!%)!!%)%)!!)J˛%))J!)J!˛)J! Á˛Δ!%)%)!˛%) !)J%))J%)%))J)J%))J%))J%)˛)J%))J!=ÔNsJR-k!%)˛)J %)BNsNs5≠• Á ÁΔ Á Á-k˛)J%))J-k%)-k)J)J!)J)J1å)J-k-k)J)J-k)J-k%)!¸%))J ÁÑ˛!B!B!!BB˙! BÚ! B˛! B!B!!BB!BB˝ c ÑÑ• ÁΔ-k-k Á%) c%)Δ%) cΔ Á %)B-k=Ô5≠F1F1JR=Ô5≠1å9Œ5≠9Œ˙5≠ 9ŒBJR Á•JRBF1JRB Á!Ñ!! ÁJRJRB=Ô5≠5≠1å9Œ=Ô9Œ=Ô5≠9Œ1å9Œ®9Œ ÁB cÑ•Δ•Δ•Δ•Δ•Δ Á!!)J!%)%))J!¸%) !˝%))J!)J!%)!%)!)J%))J%))J)J%)! ÁΔ Á Á%)˝)J %)˛)J %)˙)J%))J%)-k)J-kJRJRB˛%))J)J!1å˛JRΔΔ!Δ! Á%))J%))J%))J)J%)%)˝)J-k-k%)-k¸)J-k)J%)%))J%)%)!%)!! Á%)! c!B!B!˛B!B!B!B!˛B˙! B!B!B!B!B!B!˛B! cB c cÑ˝•˛!5≠5≠1å Á9Œ%)F1 ÁB Á)J%)F15≠5≠1å=ÔBJRBBJR=Ô¸5≠˛9Œ5≠9ŒBF1BB9ŒRîB9Œ• ! c c%)BNsBF1=Ô9Œ5≠5≠˝9Œ5≠=Ô9Œ1å1åy=ÔÑB c cΔ•Δ˚•Δ Á!%)!%)!%)!˝%)˝!%)!˘%) )J˘%)!!Δ ÁΔ!%))J%))J%))J%))J%))J˛%))J%)˛)J %)%)9ŒJRJR)J!)J%)-k)J%)F1NsRî)J•! ÁΔΔ Á%)%))J)J%))J%)Ò)J¸%)!%) Á!%)-k!%)Δ¸B!B!B˛!B!!BB˙! B˙!B!B!B!˛B!BB˝•!Δ! Á!%)9ŒF1BF1B%)=Ô c c Á9Œ9Œ1å5≠-k9Œ-kBJRF1=ÔJRNsJR=Ô5≠5≠9Œ9Œ˝5≠ F1F1-kB=Ô%)Ñ !Ñ%)5≠˛F1B=Ô˝5≠ =Ô9Œ5≠=Ô9Œ=ÔB=Ô5≠5≠∑ =ÔB cB•ΔΔ•Δ•˝Δ Á Á!!%)!%)˛!%)!%)!)J%)!%))J˛%) )J˛%))J%))J%))J%))J%))J%))J%)%)! ÁΔ Á Á!%))J%)%))J-k%)%)˛)J-k)J%)˛)JNsNsB!)J!˛%)1åNsJR9Œ• ÁΔ˛ Á%))J%)%)˚)J -k-k)J1å)J-k)J-k)J-k%)1å%)˛)J
%))J%))JΔ Á)J1å-k1å%))J1å Á˘B !˛B !B!B!B!B!B!B!¸B!B!BB c˙BÑ Á Á˛%);-k)J1åJRJRF1)J Á)J Á5≠=Ô9Œ)J1å9Œ1å9Œ5≠=ÔJRVµRîRîNsJRF1F19Œ1å9Œ5≠9Œ5≠=Ô=ÔF1 ÁB !%)5≠F1F1JRF1B=Ô=Ô9Œ5≠1å=Ô9Œ5≠5≠9Œ9Œ˛=ÔB5≠9Œô 9Œ! c cÑ••ΔÑΔ˛•ΔΔ Á!%)¸!˛%) Á%)!%)!%)!˛%)!)J!%)!¸%) !˝%) )J˛%)#! Á!Δ Á!)J%))J%))J-k)J)J%)!)J%))J!BJRRî%)!%)-k)J%)!JRJRNs ÁΔΔ˛ Á !˙)J %))J)J-k)J-k%))J)J1å˛)J-k%))J˚%) Á!)J5≠-k5≠)JB!c9ŒÑΔ cBB!B!B!B!B!B!Bˆ!B!˘B c cΔ•• cÑ!%)-k1å1å9Œ5≠=Ô9Œ!•%)=ÔRî=Ô9Œ5≠)J1å5≠-kB=Ô1å˛5≠=ÔF1F1=ÔF1B9Œ1å5≠9Œ1å9ŒF11å Ñ-k5≠NsJRJRBB=Ô9Œ5≠9Œ˛5≠ =Ô˚9Œ˛=ÔB9Œ5≠≠-k!Ñ c••Δ•Δ˛• ΔΔ Á Á%)!%)!%)!%)!%)˛!%)!¸%) )J˝%) )J˛%))J%))J%))J˙%))J!!˛ Á˛)J%)-k%)¸)J!-kJRNs5≠!%))J!)J%)=ÔJRRî1åΔΔ!Δ!Δ)J%))J%)˝)J -k˛)J-k)J-k)J-k)J-k˛)J -k˝)J%)%) Á)J1å5≠1å1å ÁB %)^˜Ns!)JÑ ÁΔ• c˛B!B!B!B!B!B!B!B!B!B!˚B c cÑ c•• Á!˛-k!5≠5≠1å9Œ1å1å)JÑ ÁB-kF11åBF1JR-k1å=Ô=Ô5≠5≠-k1å9Œ9Œ=ÔF1BF1BF19Œ=Ô˛5≠BF1B=ÔNsNsJRB˛=Ô9Œ5≠1å9Œ9Œ˛=Ô9Œ=Ô˛9Œ˛=Ô9ŒB=ÔB1åµ%)B c cΔ••Δ¸•ΔΔ˚! %)˛! %)˛!)J!%)!%)!%)%))J!%))J%)!)J!%)!%)%))J¸%)
)J%))J%)%) Á ÁΔ!%)-k%))J%)˝)J!BJRF1%)!˝%) -kJRNsJRΔΔ Á ÁΔΔ˚%)˛)J%)-k%))J-k˛)J%)-k)J%))J˝%))J%)%)!%)1å1å-k1å c ÁBcc1å!%)! Á•ÑÑ cB c˝B!B!B˛!EB!B!B BB cB cBÑ cÑÑΔΔ!!-k)J1å1å9Œ5≠5≠1å-k)JΔ!=ÔF1Rî5≠%)-kF1F19Œ-k5≠5≠1å1å9Œ-k1åJRJRF1VµJRF1JRJRF1JR-k9ŒBF1BF1B=Ô9Œ9Œ1å˛5≠9Œ=Ô9Œ=Ô˝9Œ5≠9Œ9Œ=Ô5≠=Ô9Œ=Ô9Œ˛B¡ΔB c cΔ•Δ¸• ΔΔ Á!%)!!%)%)!%)!˛%)!%)%)!%)%)!-k%))J%))J%))J!)J!)J%))J%))J%))J¸%) -k%))J%))J%)%) Á! Á)J)J-k%))J%))J-kJRJR5≠!%)!-k)J!F1NsNs-k•˝Δ%))J)J%)%))J%))J)J˛%).)J%)-k%)-k-k1å)J-k-k1å)J-k%))J)J! Á!-k1å-k! ΔVµsúkZVµ^˜kZJR5≠%)-kΔ!ΔΔ•• cÑB cB c˚B!B!˛B!BBÑÑ•Ñ•˛ Á)J)J1å-k9Œ-k9Œ5≠˛1å
%) Á=ÔJRJRcc^˜=Ô-k-k˝1å5≠-k9Œ5≠=ÔRîF1BBRîRîVµRîZ÷Z÷VµVµ9Œ5≠9Œ9Œ¸5≠9Œ9Œ˛=Ô 9Œ˛=Ô9Œ=Ô5≠9Œ5≠9Œ5≠=Ô9Œ˝BF1B∂Ñ c c˛•ΔΔ•¸Δ Á˚!%) Á!!˛%)!%)!%)!%)!)J%))J!%)!%)%)!!%)%))J˛%))J%))J%)%)!)J˝%))J-k%)%) Á%))J)J%))J!=ÔJRF1!%)%))J%)%)5≠NsNsF1•ΔΔ˛ Á%)%))J)J%)%)˛)J-k)J-k)J-k˛)J%))J-k)J-k˝%)!)J1åBRîJRF1=Ô-kZ÷kZ^˜Z÷RîNs^˜g9c)J-k)J%)˛!
ÁΔ•ÑÑ cÑ c cBB˛!˚B cBB cΔ•Δ Á!%))J)J-k˛1åBJR˛-k Á)J9ŒNsF1Vµg9g9kZkZ9Œ5≠-k9Œ-k-k˛9ŒNsBBF1RîF1RîVµ˛c^˜c^˜cNs1å5≠˛9Œ5≠9Œ9Œ=Ô5≠˝9Œ =Ô9Œ5≠5≠9Œ5≠9Œ9ŒB5≠B9Œ˛BF1B¨B c c˛B˝ c Ñ˛• Á!%)!%)!%)!!%)!!¸%)!%)%))J˛%))J%))J!¸%))J)J˚%))J%)˝)J˛%)-k%))J%)!%))J!-kF1Ns5≠!!)J%))J%)RîJRNs%) ÁΔ!ΔΔ˝! Á ÁΔ! Á˝!˝)J6-k)J-k)J-k!%)=ÔJR^˜o{^˜Vµg9g9VµJRccJRRîVµVµNs5≠Z÷g9kZJRΔ1å)J%)!%)!! Á Á•Δ•Ñ cB! c cB!B cÑ••˛Ñ c c Á%)%))J-k-k1å1å9Œ5≠=ÔNsJR1å1å%)9ŒF1RîF1Rî˛g9 o{súsú=Ô5≠)J-k1å9ŒBJRNsF1JRNsJRRîRî^˜Z÷RîRîNsRîNsJRJRNs=Ô5≠˚9Œ =Ô¸9Œ =Ô˝9Œ
5≠=Ô9ŒB9Œ=ÔBBF1BF1…B c c•ÑÑB!!˛B cΔ••Δ ÁΔ%)!%)˛!%)!˛%)!%)!¸%)!%)!%)%))J)J%)!˝%))J%))J%)!)J)J%))J!)J%))J)J%)!)J%))J%)%)BJRF1˛!
%))J!=ÔJRRî9Œ•• ÁΔΔ•%)¸!+Δ••Ñ•Ñ•• Á!)J%)-k)J-k!=ÔRîVµVµ^˜Z÷NsF1^˜RîZ÷^˜VµBJRJRRîJRJR1åVµg9kZc1å Á1å1å˝%)-!!ΔΔ•B!!Ñ••!-k5≠9Œ1å1å!)J)J-k Á•Δ-k-k1å-k5≠9Œ9Œ5≠9ŒF1BBF1F11åJRRîF1NskZg9g9˛o{kZZ÷5≠%)9Œ9ŒF1F11åF1JRcZ÷VµZ÷˛cVµNsJRNsNsVµB=Ô=Ô9Œ5≠=Ô9Œ9Œ5≠˛9Œ 5≠˝9Œ5≠5≠9Œ=Ô9Œ¸=ÔB=ÔF1BB¨B cÑ••Δ Á•Ñ˛B c˛• ÁΔ•Δ Á Á˛%) !%)!%)%)!%)%))J%)%))J!˘%)˝)J%)%))J)J˛%)˝)J˛%)˛)J!)J)J%)-kNsNs)J!˛%) !)JNsJRJR)J• ÁΔ ÁΔ Á!˛%))J)J%))J%)˛! Á Á˝)J %)%)ΔRîg9g9JRF1F1RîVµNsVµNsVµ^˜cBF1Rî9ŒNsNsVµNsVµJRNsZ÷! Á-k5≠˛)J %)%) ÁΔ cΔΔ%)BF1JRJRNsJRF1JRF1F15≠5≠BJRF11å-k9Œ1å=Ô9Œ9Œ5≠1å˝BRîRîkZ^˜VµRîkZkZg9o{wΩkZkZVµF15≠5≠=ÔB=ÔF15≠JRJRRî^˜g9o{˝kZcVµRî=Ô9ŒJRZ÷F1˛9Œ¸=Ô9Œ=Ô˝9Œ=Ô=Ô9Œ5≠9Œ˝=ÔB=ÔF1BF1F1–B c cΔΔ••˛Δ˛Ñ" ÁÑΔ•Δ•Δ•Δ•ΔΔ!!)J%)%)!!%)!!%)!%)!!%)!%)%)!)J!)J¯%))J!%)!)J%)˛)J %)-k%)%) ÁJRF1F1!! Á!%))J9ŒNsJR9ŒÑΔΔ ÁΔΔ%))J!)J%)!!˛)JQ%)%)!-k)J-k1å5≠=ÔBF1Rîcg9Z÷RîJRBZ÷^˜NsRîVµVµF1F1^˜RîZ÷g9NsNsJRJRF1cΔ=ÔRî%))J!)J-k)J%)!Δ Á%)%)BF1RîNsRîNsJRNsJRNsF1F1JRJRBNsRîRîB5≠=Ô9Œ=Ô5≠=ÔJRB=ÔNsZ÷c˝kZ&ckZco{súc^˜g9^˜RîZ÷=ÔF1=Ô9ŒNsJRJR^˜g9kZo{g9o{kZo{súwΩwΩ^˜-kB-k1åVµ^˜9Œ1å5≠˝9Œ=Ô1å9Œ5≠9Œ5≠9Œ=Ô¸9Œ=ÔB9ŒB=ÔF1BF1≠ c c•ΔΔ•˛Δ • ÁΔ Á Á! Á!Δ Á¯Δ Áˆ%))J%))J˛%) )J˛%) )J˛%) )J˛%)˛)J%))J%)˛)J%)-k!5≠F1Ns-k!!%)!%)%)JRF1JR ÁΔΔ Á ÁΔ Á˚%))J%)Δ!=ÔF1NsVµcg9o{súo{^˜^˜˛c$^˜JRRîBZ÷Z÷Vµ^˜g9g9Z÷F1Z÷cZ÷^˜VµF1JRF1g91å-kÑVµJR=Ô=Ô1å! Á)J)J-k)J1åB˛RîZ÷VµVµRîRîJRRîNsNsF1JRRîNsVµRîVµNs5≠B-k=ÔBBNsVµg9˛^˜˛g9-c^˜kZo{o{g9cg9^˜csúo{o{RîJRBRîkZo{kZkZo{o{kZwΩsúcNs=ÔJRRîJRΔ9ŒJR^˜g9NsB1å=Ô=Ô9Œ9Œ=Ô5≠˛9ŒB=Ô˛9Œ =Ô˝BF1BBF1B∂B cÑΔ•Δ•Δ˛•ΔΔ Á Á¸! Á˜Δ! Á˛%) !)J!%)%))J%))J%))J¸%)"!%)!!)J%))J)J%))J%)%))J%))J%))J%)%)BJRB! Á!!%) Á=ÔJRRî-k•Δ Á˛Δ˘%)ΔF1Ns%)F1g9Z÷VµVµNsF1F1Rîcc^˜^˜Rî=ÔkZ˛Z÷c^˜VµckZ˛c NsRîNsJRF1cB B1å=ÔVµ1å9Œ5≠5≠%)=Ô)J%)1åF19ŒJRRîJRJRRîRîZ÷VµZ÷Ns˛Rî%NsRîRîJRZ÷RîNsB-k=ÔBNsRî^˜ckZg9g9^˜g9Vµo{^˜kZsúo{kZo{kZkZsú{fisúsúo{kZZ÷JR˚o{
súsúRî=Ô=Ô5≠1å Á!RîΔÑ%)5≠˛cJR1å=Ô5≠9Œ5≠9Œ5≠9Œ5≠=Ô5≠=Ô5≠9Œ9ŒB=ÔB=ÔBF1BBJR„ Ñ c•ΔΔ•ΔΔ Á•Δ• Á˛!%)!˛%)!%)!! Á˝Δ •˛Δ Á!%)%))J%)%)!)J%))J%))J!%))J)J%))J!!%))J%))J%))J%))J%)˛)J%)%)1åJRF11å Á%)!)J!-kF1RîJRΔ• ÁΔ Á•!)J%)%)˛)J%)ΔVµkZVµRî)J-kBNsJRRîVµ^˜cRîRîZ÷RîF1Bo{^˜kZg9^˜˛g9Go{g9^˜JRRîVµVµBcNs !=Ô=Ô-kRî^˜9Œ=ÔB9Œ5≠B9Œ)JF1=ÔJRNsRîZ÷^˜^˜VµVµRî^˜^˜VµRîZ÷NsNsZ÷JRNsNs-k=ÔNsVµVµZ÷g9súkZsúkZsúVµg9Z÷csúsúo{súg9o{wΩ{fiwΩ˛sú2cg9g9súsúwΩo{wΩwΩo{Z÷súwΩsúwΩˇ5≠=ÔVµRîB5≠JRRî^˜ccVµ1å=Ô9Œ=Ô9Œ=Ô9Œ5≠9Œ=Ô9Œ9Œ=ÔB=ÔF1=ÔF1BBF1JRBƒ c c•Δ•Δ¸•ΔΔ! Á˝! %)!!%)%)!%)!!Δ ÁΔ Á¸Δ Á Á%)%))J¸%) )J˚%)!%)!)J¸%))J%))J%))J%)BJRF1 Á!!%)!!=ÔNsJR-kÑ ÁΔΔ Á Á˛%)<)J! Á Á!JRcZ÷Z÷JR!VµRîBg9^˜g9B5≠5≠B^˜F19ŒNsg9kZcg9c^˜o{o{VµVµNsVµRîRî=ÔcVµ Á ÁJRJR9Œ1åBB=Ô5≠1å1å)J-k%)F1F1Ns˛Z÷˝cF^˜Z÷Vµ^˜^˜VµRîJRF1B=Ô9ŒBRîZ÷Z÷F1BVµJRF1g9cRî^˜Rîg9súo{kZo{g9o{sú{fiwΩsúsúwΩsúo{kZJRo{o{kZsúRî!5≠RîkZwΩsúwΩo{^˜o{wΩo{g9kZccg9g9cg9Rî-k9Œ˛5≠
9Œ=Ô9Œ9Œ=Ô9Œ=Ô=ÔBBF1˛BJRBBæÑ cΔ•Δ•Δ•˝Δ Á!%)˛!˛%) !˛%) !%)%))J%)%)!!Δ Á˛Δ ÁΔ! Á%))J)J˛%))J%))J%))J%))J˛%)-k%))J%)%))J%)%))J)J-kJRNs)J Á!%)%)!)JF1NsB•¸Δ˛%) ÁΔ!1å9ŒRîcZ÷^˜Z÷)JRîkZ˝g9 5≠1å!!JRRî5≠Vµo{cg9g9c˛g9RîVµ˛RîVµF1RîkZ1å cÑ c=Ô˛B˛=Ô 9Œ=Ô=ÔF19ŒF1%)NsF1Vµ˛c¸g99^˜Z÷RîZ÷VµJR9Œ=Ô=ÔNsNsVµ=Ô!%)-k-kBB=Ô9Œ)J-k9Œc^˜Z÷o{g9kZo{{fiwΩsúsúwΩ{fic^˜g9NsZ÷^˜co{súVµ9ŒNs^˜g9^˜^˜kZcsúg9sú˛wΩkZg9c^˜g9cB1å9Œ5≠9Œ9Œ=Ô9Œ=Ô9Œ=Ô9ŒB=ÔBF1BB˝F1 c c•Δ˛•ΔΔ•Δ Á Á˚! %)˝!%)%)!%)!%)%))J%))J%)!Δ Á• Á˛Δ Á!%)%))J)J%)%))J%))J%)˛)J˛%) )J˛%))J%)!BNs=Ô Á%)!!%)%)BNsJR%)•˝ Á2Δ%)Δ)J9ŒJRRîVµcc^˜Z÷JRRî%)=ÔVµVµco{VµB9Œ%)!Vµ=Ô9ŒVµo{g9VµccsúcNs^˜RîVµVµZ÷JRF1Z÷Rî! cÑ!-k˛BBF1F1BB=Ô9Œ=Ô5≠BΔRîJRNsZ÷^˜g9kZg9cg9cc^˜Z÷NsNsRîJR9ŒNs5≠c)J-k^˜g9Rî5≠!9Œ1å-k%))J=ÔRîNsZ÷^˜g9o{wΩwΩsúwΩwΩ{fiZ÷Z÷c^˜^˜Z÷cg9g9^˜˛kZ^˜ckZg9cg9VµVµZ÷Z÷cg9kZo{cZ÷cZ÷c=Ô1å˚9ŒB9Œ=Ô=ÔBBF1˝BF1BÀÑÑΔ•Δ•ΔÑΔ•Δ Á!!%) Á%)˛! %)%))J!!%)%)!%)!˝%))J%)˛)J !˛ ÁΔΔ Á!!˝%))J%))J%))J%))J˛%)˛)J%)%)5≠NsJR%) Á!%)!%)-kJRJRBÑ•Δ• Á ÁΔ)JNsRî¸c^˜Z÷VµF1RîB=ÔZ÷=Ô^˜F19Œ5≠5≠BVµZ÷Vµ5≠1å1åRîg9Z÷cZ÷RîVµ˝Rî>NsRîVµ^˜1å cΔBÑF1BF1JRF1NsJRF1F1B=Ô9Œ9ŒÑVµZ÷RîZ÷Z÷^˜g9g9o{kZkZg9cVµcRîNsZ÷Vµ1å9ŒBwΩwΩo{o{sú{fiˇ!%))J)J5≠B9Œ9ŒBg9o{˛súwΩ{fi{fig9súkZZ÷^˜cg9cg9ckZkZg9ckZckZcg9cZ÷^˜NsRîRî˝Vµ^˜cVµNsc=Ô1å˛9Œ=Ô=Ô9Œ˛=Ô˛BF1BF1BBF1Õ cÑ•Δ•Δ•Δ•ΔΔ Á Á¸! %)˝!%)!!%)%)!%))J%)!)J!%)%))J%))J)J%)! Á Á˝Δ Á!%))J)J%))J˛%) -k%))J%))J%)%)!NsJRBΔ%) Á!%)%)BNsRî%)ÑΔΔ Á•Ñ5≠Z÷Ns^˜g9g9˝^˜NsJRNsVµ^˜˛=Ô"5≠-k1å%)!ΔVµ^˜súc-k=Ô1åF1cNsF1Z÷VµZ÷RîVµNsRîJR^˜=Ô c Á• •JRF1F1˛JRF1JR˛B
9Œ5≠1å=ÔRîBRîg9c^˜c¸kZc^˜Z÷Vµ^˜^˜B5≠Z÷Vµ^˜csúwΩˇ-k! Á Á%)^˜Ns9Œ9ŒNsRî¸sú{fi^˜^˜c^˜˛g9/kZkZg9kZg9ccg9^˜^˜cg9g9^˜Vµ^˜VµRîZ÷Z÷RîVµRîRîZ÷VµRîRîZ÷9Œ5≠9Œ5≠=Ô9Œ9Œ=Ô9Œ=ÔB=ÔBBF1=ÔBBJR√Ñ•Δ•˚Δ Á Á%)!%)!%)!%)˝!%))J¸%) !˛%))J%)!%)%))J)J%))J)J%)!! Á ÁΔΔ Á%)!¸)J %)˛)JO%))J!9ŒJRJR%) Á!!%)!1åNsNs=ÔÑΔΔ ÁΔÑB^˜JRcsúcg9o{g9cVµNsJRRîZ÷^˜RîVµZ÷Ns1åΔÑ!5≠=ÔZ÷ckZF15≠F1F1Z÷NsVµVµ^˜VµVµRîNsRîVµZ÷ Á%)•!!5≠JRBJRF1JRNsNs˝B)9Œ-k)J!Z÷VµNsZ÷cg9cg9kZkZg9g9^˜ccZ÷JR9Œ5≠F1Vµco{g9o{sú-kÑ! Á!o{wΩwΩkZF1Bg9˛sú{fiˇZ÷VµcckZ˛g9!kZckZc^˜Z÷RîRîZ÷cckZg9Z÷cZ÷VµVµ^˜Z÷^˜Z÷VµNsRîVµcZ÷Z÷Vµ=Ô5≠9Œ9Œ˝=ÔB=Ô˝F1˝B‘ c••Δ˝• Δ ÁΔ Á!%)!)J!%)!%)¸! %)!%)%)!)J!%)%)!˝%)˝!%)%))J%))J!%) Á Á˛Δ+%))J)J!)J%))J%))J%)%)F1F1=ÔΔ Á!%)%)!F1NsNs ÁÑΔ ÁΔ cF1VµBNssúF1-k-k9Œ^˜c^˜JRRîVµ˛Z÷VVµZ÷NsNsF19ŒBc5≠1åg9cc=ÔJRVµZ÷cVµZ÷^˜Vµ^˜RîNs^˜Vµ)JΔ c!B RîBJRF1JRF1NsF1F1B9Œ9Œ-k! Á NsZ÷BNskZg9kZo{súg9g9^˜cNs)JΔ)J-kJRNsVµo{kZsú{fic!%))J5≠Z÷súsúg9o{súo{kZ˛o{*wΩZ÷JRZ÷cg9ccg9g9cg9Z÷NsJRJRRîkZg9g9súo{kZsúkZg9Vµ^˜^˜Z÷^˜^˜Z÷^˜VµRîVµVµZ÷VµNs9Œ9Œ˛=Ô9ŒB=Ô˝B F1˛B F1»ÑΔΔ•Δ•˝Δ!!˛%)!)J Á%) Á%)%)!!˚%) )J¸%))J!)J˛%))J%))J%))J%)˛)J%)%)!! ÁΔ!%)%))J%))J)J%)9ŒJRJR-k Á!!%) Á9ŒNsRî1å•Δ ÁΔÑRîcNsRîo{Vµ-k1å=ÔB-k=Ô=ÔRîZ÷^˜VµZ÷VµJR9Œ%)-k=ÔNssúc=Ô-kJRo{o{NsVµRîZ÷cc^˜VµVµJRJR^˜Z÷)J cBB c!=ÔJRF1F1NsF1JRNsJRF1B9Œ)J! Á! 9ŒZ÷JRVµVµ^˜c^˜VµZ÷RîZ÷Z÷%))J9Œ1å=ÔF1VµRîcg9súo{{fi9Œ!-kg9wΩ˛o{súwΩwΩ˛súg9RîkZVµc˛g9ckZcZ÷Ns=ÔJRZ÷kZsúo{kZ^˜^˜kZwΩkZo{¸cg9cc^˜c^˜RîVµVµZ÷Z÷JRB9Œ=Ô=ÔB=ÔF1=Ô˙B F1« cΔ•Δ˛•Δ•Δ Á!!%)˝!%)%)˛!%)!!%)%)!%)!%)!!%)%)!%)!˘%) )J˛%))J%))J%))J!! Á!!%)%))J%)F1JRF1Δ˝!R%)NsNsF1ΔÑΔ•ÑZ÷Z÷F1BZ÷g9-k1å5≠9ŒBJRJRRîJRZ÷F1Z÷o{o{Z÷Ns=Ô=ÔNs1åccB=Ô9ŒZ÷cZ÷^˜cVµZ÷cZ÷NsRîRîcNs9Œ cB c••ΔNsBJRJRNsJRF1BB=Ô5≠)J!Δ! Δ1å^˜^˜NsJR˛Z÷˛Vµg9=Ô9ŒRî˛c˝sú o{súwΩsú5≠1åco{súkZo{sú{fi˝sú.c^˜g9g9kZg9ccg9kZVµB5≠=ÔRîg9o{o{g9ccg9^˜co{^˜^˜súkZo{g9RîJRVµRîZ÷VµZ÷RîVµNsRîRîVµF1B9Œ˝=ÔB=ÔF1BB=ÔBBF1—ÑΔ ÁΔΔ•Δ ÁΔΔ!!%)%)!!%) Á˝!%)!)J!˛%)!)J˚%)!)J%))J%))J%))J˚%))J)J%)˝)J%)!˛)J!5≠JRNs)J Á Á%)!!=ÔNsNs1åÑΔΔ cJRZ÷BB=ÔkZJR=Ô1å=Ô9Œ=ÔJRZ÷^˜Z÷F1F1g9g9Z÷Rî^˜ckZo{9ŒJRkZRî9Œ9ŒVµRî^˜ccg9Z÷^˜Vµc^˜VµF1B cB cΔ1å)J9ŒNsF1NsRîNsJRNsBB9Œ-k%)• !)JNsRî%)o{JRJRRî^˜Z÷RîRîZ÷Z÷5≠g9g9kZsúsúkZsúkZsúo{wΩsúc=Ô=ÔZ÷kZo{o{wΩ{fisúsú{fisú^˜^˜.g9kZccg9kZg9cB-k5≠Rîg9kZg9g9cg9g9^˜g9cZ÷kZco{wΩg9Vµg9o{Z÷-k1åg9kZZ÷NsJRRîNsRîRîZ÷BNs=Ô˝B F1˛B F1˛B‚ cBB cB cB c c•Δ•Δ Á Á!˛%)!%)%)!! Á˝%))J!˛%) !¸%) !)J!%)%)!)J)J%))J˛%))J%))J%))J%))J%))J%)%)F1NsB Á%)˛!%)NsF1NsΔ••Ñ)J^˜BNsF1Ns^˜B1å5≠5≠=ÔBJRNsVµNsZ÷Z÷Ns=Ô9ŒF1Ns)J^˜c=Ô9Œsúg9F1Z÷^˜cZ÷Vµ^˜Z÷VµVµRîZ÷F1JRVµ cBÑ-kF1F19ŒF1BNsJRNsJRJRBB1å)J%)B BΔF1F1^˜=Ô-kkZ^˜JR^˜VµRî^˜VµBF1-kBBNso{o{súwΩsú{fikZkZo{cVµckZsúsúwΩo{súsúkZ^˜c^˜kZ^˜cg9g9cNs)J-kRîsúo{g9g9c^˜Z÷ckZF1g9JRF1c˛Rî •5≠ Á-kg9sú=Ô9Œ1åRîZ÷NsNsRîNsRîRîJRJRZ÷5≠B=Ô=ÔBBF1F1BB=ÔF1ÿ•Ñ˛ cB cBB cΔ•Δ•Δ•ΔΔ Á Á˛! %))J%))J%)!%))J%))J!)J˛%))J!)J˙%))J)J%)%))J˛%)˛)J%))J)J%)1åNsJR)J!˛%)!9ŒJRRî-kÑ••!^˜RîBRîJRJRNsNs5≠F19ŒF1F1˛NsL^˜o{cJRB=Ô^˜JR9ŒJRcNs9Œ{fisúc^˜Z÷cg9RîRîJRRîVµRîF1NsVµΔ!ÑJRVµRîNsNsBJRNsRîJRJRBF11å5≠%) c!! ÁBRîVµZ÷c)Jg9RîNsVµZ÷Vµ^˜-k^˜ˇcwΩkZo{wΩsúwΩsúwΩ˛o{&Z÷wΩ^˜o{wΩwΩ{fio{súwΩ^˜^˜g9ckZ^˜cg9kZVµF1)JF1kZsúg9g9cckZg9Vµ^˜NsVµc9Œ^˜Rî˛c NsRîRî=Ô)J-kRîNs1å9Œg9VµVµZ÷VµRîRîJR9ŒNsRî9ŒB=ÔBBF1BB=ÔBBÿ•ΔΔ˛•ÑΔÑΔ Á!Δ Á˛Δ
•ΔΔ•Δ Á Á!%)!)J˛%) )J˛%))J!)J%))J˛%))J!%)%))J%)!¸%))J%)˛)J3%))J%)BJRB Á%)!%)!!NsNsF1••B%)kZcF1=ÔBF1RîJRRîB=ÔNs9ŒBJRJRco{g9RîZ÷Z÷JRwΩVµ1å9ŒcZ÷1åcZ÷Vµ˝c|BJRF1JRJRF1NsVµ•B cZ÷g9VµNsRîBF1NsNsJRF1F1B5≠)J)JÑ !ΔJRVµNsRîVµcBo{^˜RîF1Z÷cJR5≠Z÷^˜Z÷súo{kZo{súsúwΩco{súkZg9kZsúo{wΩ{fisúsúo{súg9ccg9^˜cg9g9Vµ1å-k^˜kZccg9ckZc^˜RîVµRîRîkZJRZ÷RîZ÷F1c^˜JRZ÷^˜cRîRî)JVµcΔ5≠F1súcNsRîRîJR5≠BRîJR9Œ˛B=ÔF1˝BflΔ•Δ•Δ•ΔΔ ÁΔ!!%)!%) Á%)! Á ÁΔ• Á˛Δ Á Á!%)˛)J!%)%))J!˛%)!)J%))J¸%)S)J%)-k%))J%))J!-k%))J!9ŒNsRî1å Á!%)!!=ÔNsRî1åÑB1åg9súNsB9Œ5≠VµRîF1Z÷Z÷JRBJRJRNsRîo{kZg9cVµ9Œ9ŒsúJR5≠9Œo{o{F1VµcVµcg9cc^˜RîVµNsNsJRZ÷Δ c•=ÔkZVµNsZ÷NsF1JR˛Rî+NsB9Œ-k)J)J!B•9ŒJRNsB^˜^˜NsVµo{^˜cZ÷^˜g9-k9Œsúcg9kZwΩsúo{súsúo{kZsúZ÷wΩo{o{súwΩˇ˛kZ9súwΩo{^˜g9VµkZkZg9JR-k9Œo{g9g9kZo{RîNsZ÷cZ÷VµZ÷Rîsúg9RîRî^˜Z÷ckZg9cg9cZ÷g9kZNs!5≠5≠B!-kJR^˜Z÷VµJRBBNsRîF19Œ¸B=ÔBB”˛•Δ••ÑΔ•Δ!! Á!!%)!! Á%)!! Á! Á˚Δ Á!!%))J)J˛%)!)J˝%) !%)%))J%)!%)%))J%)%))J!˛)JBNsB˝!@%)-kNsJRJR• c=ÔkZo{VµRî1åBg9^˜VµBNsVµcRîRîVµZ÷o{^˜RîRîZ÷VµVµ=ÔVµJR1åBsúo{RîVµZ÷^˜Vµ^˜g9cRîZ÷JRNsBRî-k•%)JRcVµRîRîNsB%)=Ô˛5≠-=Ô=Ô5≠)J-k!!!F1Z÷^˜Rî^˜cg9)J{fi^˜Ns^˜Z÷JRcNssúg9o{g9kZo{súwΩsúkZg9o{VµJRJRsúkZo{wΩg9cc˛súkZc^˜kZg9g9=Ô%)F1sú^˜kZZ÷RîkZkZF1co{JRVµRîwΩkZNs^˜kZ˛cZ÷^˜˛Z÷g9Z÷^˜c^˜9Œ9Œ1å5≠)JF1Nsg9VµRîRîNsJRRîNs=Ô9ŒF1=ÔF1=Ô˛B‡ ΔΔ••Δ•Δ• Á Á%) Á%)˛!%)!%)!%)!)J!˛%) Á!!˝Δ! Á˛%))J)J˛%) )J˛%))J%))J%)-k%))J%))J%))J%))J5≠NsJR9Œ Á!˛%)F1F1Rî-k!=Ôg9kZg9RîZ÷1åZ÷Z÷RîRîVµF1BJRZ÷NsckZ^˜Z÷c^˜^˜VµJR1åkZNsF1F1^˜Ns^˜^˜ccVµ^˜kZZ÷VµRîRîJRNsB-k=ÔJR^˜VµRîVµRîZ÷F1VµRîRîNsJR1å%) Á)J c!!•JRcsúwΩVµg9B^˜^˜Z÷JR=Ôc^˜Rîo{g9co{súkZsúsúg9cZ÷kZkZZ÷Z÷F1RîwΩwΩ^˜cg9wΩo{o{kZkZZ÷kZg9c9Œ5≠Z÷wΩcg9sú9Œ!g9kZg9kZF1Z÷Rîg9Z÷Z÷g9Z÷^˜c^˜Z÷cZ÷^˜˛g9
o{kZcg9o{c^˜^˜g9c^˜kZVµRî˝Ns VµBB=ÔBB=ÔBB=Ô»˘•Δ Á!! Á˚!%) Á%)!%)!%))J˝%)! Á Á˛Δ Á Á!!)J%)%)!%)%))J%))J˙%)i)J!)J%)BJRRî Á Á!%)!1åF1NsB!JRkZRîkZNscRîB^˜VµNsRî^˜Z÷RîRîZ÷VµZ÷RîRîc^˜^˜NsF1-k=Ô{fic=ÔNsNsVµZ÷ccg9Z÷^˜^˜VµVµRîJRRîJRF1NsRî^˜Z÷Vµ^˜Z÷Z÷F1NsJRNsJRJRB9Œ)J5≠1å B!VµkZsúg9cF1F1^˜VµF1JRRîccF1RîcVµ˛sú
ckZ=ÔBBkZZ÷^˜VµVµ5≠˛c
g9wΩkZsúcsúVµco{c)JF1g9o{˛g9%^˜B)JkZo{c^˜NsRîVµVµ%)5≠BF1Vµ^˜^˜g9kZwΩsúwΩo{cZ÷RîB=ÔBcsú^˜RîVµNs^˜B˛Ns JRJR=ÔNs=ÔB=ÔB=ÔF1BB—Δ•Δ˝•ΔΔ Á%)%)!!%)%)!%)%)!%)!%)!˝%) )J˛%))J%)%) ÁΔ Á˝Δ!%)˛)J%))J!)J%)!%))J%)%))J)J%)-kJRNs=ÔΔ˛!&)J9ŒNsRî ÁBsúNssúVµ^˜B1åBJRZ÷RîRîcVµZ÷^˜Z÷VµZ÷Z÷^˜cg9=ÔJRNsJRF1wΩ{fiNsRîZ÷˛^˜=g9g9^˜VµZ÷Z÷VµVµZ÷RîRîco{^˜g9Vµ^˜Z÷^˜NsJRNsRîNsJRB5≠-k1åRî!!•!Nso{wΩsúcRîNscVµF1Ns^˜g9Z÷VµNs^˜RîRî^˜wΩo{NsRîRî)Jg9o{˝Z÷Vµ^˜g9c{fisúg9cg9Ns=Ô9ŒJRΔcsúcg9g9VµZ÷Bg9=Ô˛kZRîZ÷g9kZ^˜g9NsRîNsZ÷Z÷{fi{fiwΩwΩ{fisúo{cVµF19Œ1å1å%)BkZ˛VµRî=Ôc9ŒF1˛JR1åJR=Ô¸B =ÔÀÑΔ˚•Δ! Á Á!! Á˚!%)!˛%)!!%)%)!%)!)J˝%) Á ÁΔ ÁΔΔ Á%)%))J%))J!)J%)%)!˝%)!=ÔJRJR%) Á˛!$-kJRJR9Œ-kˇNsg9g9VµNs-k%)F1)J1åVµcVµZ÷VµRîVµZ÷cg9Z÷^˜F1JRg9kZRîF1Z÷súB˛Vµ ^˜˛c^˜Z÷VµVµ˝Z÷!o{wΩwΩcVµZ÷VµcZ÷JRF1RîNsJRB=Ô5≠=ÔNsNsÑ!Vµ^˜ckZo{wΩZ÷Z÷^˜VµBNs˛c9RîVµcRîVµZ÷Nsg9Z÷=ÔVµRîg9g9c^˜^˜Rîcg9g9^˜ccg9VµZ÷Ns=Ô=Ô1å-kwΩ{fisú^˜kZ^˜cJRVµRîRîcg9JRRîJRF1F1JRVµ^˜kZkZsúwΩ{fi˛wΩsúwΩsúwΩ˛súo{súwΩwΩo{c^˜F1F1JRNsB^˜RîNsBB9ŒB=ÔB=ÔBBF1Œ
ΔÑΔ•Δ•Δ• Á Á%)˝! Á!!%)!%)!)J!%)!)J˚%)
!)J!%)%))J!%) Á ÁΔ˝ Á%)%))J%))J˛%) )J˛%)NsJR9ŒΔ˝!(=ÔNsB=Ô{fiVµVµcVµNsNs-k!1å5≠1å-k5≠9Œ=Ô%)Vµco{g9^˜RîBF1o{{ficVµF1RîF1RîVµZ÷Z÷g9˛c^˜Z÷Z÷VµVµg9kZkZ˛sú\Z÷^˜VµZ÷^˜RîF1RîNsNsF1F1=ÔBF1Rî9Œ %)súo{kZg9súkZ^˜Z÷VµJRNsg9c^˜c^˜^˜c^˜Z÷VµVµcVµNsJRkZo{g9g9cg9^˜g9súg9súcVµNsNsF19Œ=Ô Á9ŒwΩ{fiwΩc=Ôg9^˜Z÷c^˜o{^˜kZZ÷F1BJRF1RîckZo{súˇˇ{fi{fiwΩ˝ˇwΩsúo{^˜JR-k-k!1åckZcZ÷B9ŒNsVµRî^˜VµB=ÔBF1=Ô¸B¿%)•Ñ•Ñ˛• Á Á˝! Á Áˆ!%)!¸%)'!)J!%)!)J%)%)!! Á ÁΔ Á Á! Á%))J)J!)J%))J!9ŒNsJR!! Á%)!%)JRJR=ÔwΩVµRî˛Vµ JR=Ô%)%)5≠1å5≠5≠9ŒF1-k=Ô˛o{VµVµ9ŒBg9{fisúc˝VµRîVµZ÷Z÷˝cRîZ÷VµZ÷Z÷kZkZo{g9o{RîNsJRccVµ=ÔJRNsNsJR˝F1NsJR! RîwΩo{súsúo{^˜VµRîNsRî˛c˛^˜ Z÷^˜VµcRîo{Z÷^˜Z÷^˜kZkZ˛g9Lccsúo{o{{fikZ5≠Bg91å5≠•BVµRîco{B5≠g9^˜Vµg9cRîRîNsRîRîF1F1^˜co{súwΩo{o{wΩ{fiwΩˇwΩ^˜RîJRsú{fisúwΩo{Ns5≠9Œ9ŒkZ{fig9RîZ÷JRJRBRîg9^˜=Ô9Œ=ÔJR=Ô=ÔBB9ŒF1Δ )J!ΔÑΔ•Δ• Á!%) Á%)˛!%)!!%)!!¸%)!)J%))J¸%))J)J˝%))J)J%)!%) Á!Δ!˛ Á%)%))J%))JF1JR=ÔΔ Á%) Á!9ŒJR9ŒsúRî^˜Rî^˜Z÷NsJR9Œ%)1å1å˛9Œ
Z÷^˜Z÷g9c^˜^˜cVµF1NsF1NsRî˝NsJRNs-k Rîo{Z÷kZc^˜^˜ckZo{c^˜c^˜Z÷NsNsg9g9˝cg9cg9g9sú˛o{ súwΩo{kZg9kZRî1åg9kZ1åNsJR ÁkZcVµVµZ÷VµZ÷Z÷VµZ÷^˜F1cg9o{kZg9g9˛kZ g9g9kZkZg9g9o{g9cg9cg9˛c ^˜cZ÷VµVµRî^˜Z÷^˜VµJRNsNsVµ^˜NsJRBRîZ÷Ns5≠F1JRRîZ÷F11åRî˛=ÔÕ Ñ˝•Ñ•˚ Á !˝ Á!!¸%)! Á Á•˛Δ-• Á Á%)%))J%))J!%)%))J%)!%)%)!)J%)%)!%)!%)F1B5≠ Á Á!%)%)JRRîVµZ÷Z÷^˜Z÷^˜Z÷Z÷JR5≠súkZ˛o{
kZg9g9o{wΩsúo{g9cRîZ÷˛RîZ÷Z÷NscVµJRRîBRîccNsZ÷BRîRîNsF19Œ=ÔRîF1Vµ%)9Œ˛=Ô´Ñ•Ñ˝•˜ Á! Á%)¸! %)!!%)%)!)J%)! Á˝Δ Á Á˚%)˛)J¸%)F1B=Ô•! Á!ΔNs˛Z÷˛^˜/Z÷^˜RîZ÷5≠BckZo{{fikZ-k1å5≠^˜Z÷NsBRîg9^˜c^˜^˜Z÷c^˜Z÷Z÷cNs9Œ1åBF1g99ŒVµRîZ÷-k-kF1^˜^˜cZ÷c˝Rî B˝JRRîNsNsJRNsNsB Vµˇ^˜VµVµRîNsVµg9kZg9^˜o{Z÷JRF1^˜kZ¸csúwΩ˛sú:wΩkZkZsúwΩsúsúkZo{Rî9Œo{co{súNsVµcJR^˜g9^˜kZZ÷Z÷^˜Z÷NskZkZo{o{VµBwΩo{o{súkZcg9cg9g9kZo{wΩ{fi{fio{o{g9Z÷RîVµRî^˜Vµ^˜˛Z÷cJRF1JRF1JRg9Z÷Rî^˜BNsRîJRB5≠9Œ˛JR9Œ!=ÔBB•ÑÑ••ÑΔ˝ Á!! Á! Á%)˛!%)!%)!%)!%)!!%)!%))J!)J%)! Á Á˛Δ4 Á Á)J%))J%))J%))J%))J!1åF1JR%)Δ Á!Δ9ŒVµ^˜VµZ÷^˜Z÷^˜c^˜o{Rî)JJRkZkZˇ=ÔJRB)JJRkZNsJRJRg9Z÷cZ÷c^˜c˛^˜cB%)RîF1cg9^˜cg9cZ÷5≠F19Œc^˜VµcRîJRF1˝JRcNsF1NsNsRîNsRîNsNsÑ)JˇZ÷Ns^˜JRNsVµg9g9kZcsúZ÷NsBZ÷g9g9cg9ccwΩ{fiwΩwΩsú{fikZo{súwΩo{wΩsúsúc=ÔkZsú^˜{fiB9Œo{JRRî^˜Rîc^˜^˜co{1åNsNsg9súˇsúc^˜csúo{o{cg9kZo{{fi{fiˇ{fiwΩkZo{cg9g9kZkZo{kZsúg9cVµ˛RîJRNsJRF1cZ÷Rî^˜JRNsVµF1B9Œ5≠=ÔF1JRRîΔB-kBÎ Ñ•ÑÑ••Δ Á! Á Á!˛ Á ! Á Á!%) Á%)!%) Á!!%)%)!%)%)!%)!%)%)-k!! Á ÁΔ ÁΔ!!-k˝%)e)J!9ŒJR=ÔΔ Á ÁΔ%)NsZ÷RîZ÷Z÷c^˜^˜Z÷c{fikZΔ^˜o{wΩJR1å^˜BVµZ÷Z÷Rî=ÔZ÷ccZ÷^˜Z÷c^˜cZ÷cVµ-k=ÔkZ^˜súkZo{o{súsúBNs=ÔNskZc^˜cNsF1NsJRJRF1NsF1NsNsRîNsNsJRRî-k o{o{Bg9NsRîVµg9kZg9g9súVµJR=ÔZ÷kZc^˜g9˛cI{fiwΩwΩsú{fio{kZo{wΩo{súwΩsúg9Z÷JRwΩg9kZc1åwΩ5≠Rîg9Z÷cZ÷VµRîo{g9JRRîVµJRRîNssú{fiRîF1wΩo{o{g9kZkZg9c^˜kZkZ^˜cco{o{wΩwΩ{fi{fiwΩZ÷cVµNsRîJRZ÷Z÷F1F1B˛RîZ÷NsNsJRVµ9Œ9Œ5≠-kF1RîVµ•B%)9ŒŒ Ѹ•Δ! Á Á! Á! Á˛! Á˝!)J!%)!%)!%)%))J˘%))J)J%)%) Á!Δ ÁΔ!!)J)J%)%)F1JR)J Á! Á ÁBcVµVµ˛Z÷˝^˜súg9 ÁcB Á5≠Bg95≠súZ÷Z÷=ÔRîg9c^˜c^˜Z÷˛^˜Z÷NsJR=Ôsúo{o{kZ˛o{sú^˜RîVµBVµ Á-kVµ^˜JRNsJR=ÔJRNsJR˝NsyRîNsRîJR c-k{fiVµBVµRî^˜kZg9g9o{o{VµNs=ÔVµg9g9^˜g9cg9^˜co{{fiwΩ{fisúkZo{súo{súwΩ{fiwΩc=Ô{fig9g9c1åg9F1JRo{cNs1åF1RîZ÷B1åRîg9o{súNs5≠-kF1c=ÔZ÷súkZkZ^˜^˜VµJRB9ŒJRZ÷g9co{súkZg9g9cZ÷cVµRîZ÷Z÷VµRî^˜cRîB=ÔRîVµZ÷RîJRJRNs=Ô5≠9Œ5≠1å=Ô9Œ-k9Œ-k1å¥˛Ñ
•Ñ•Δ Á Á! Á! Á!˛ Á! Á˚! %)˛!%)!%)!˘%))J%))J)J%)˛! Á!%) Á5≠JRBΔ!˛ Á c˛VµZ÷Z÷˛^˜g9g9sú^˜!Ns9Œ-k5≠Ns^˜NsVµcF1B^˜kZVµ˛^˜ VµVµc^˜-kB=Ôcsúg9kZo{o{súo{sú^˜o{BRî-kBF1g9F15≠BF1BNs˛JR¸Ns Rî-k g9{fi1åVµZ÷kZkZg9cg9sú^˜NsBRîkZg9^˜cg9c^˜cc^˜sú{fi{fig9g9˛o{-súwΩsúsúF1c^˜cg9Rî-kVµF1g9cB)JF1g9kZcsú9ŒRîkZcRî5≠9Œ=Ô=ÔNs^˜súg9^˜RîNsF1=Ô=ÔJRVµ^˜g9g9˝kZsú{fikZ^˜VµZ÷NscZ÷Z÷RîNsZ÷kZNs=ÔF1˛VµBRî=ÔF1¸5≠ F1˝5≠»˝•Δ•!Δ! Á! Á! Á Á!! Á! Á˛%)!%)˛!%)%)!˛%) )J¸%) )J˛%))J%)¸)J %)%)BNs-kΔ!!ÑVµ˚Z÷ ccZ÷súg9g9kZ Á%)B-kB^˜kZRî^˜Z÷F1JRo{^˜^˜c^˜^˜súg9B9ŒF1c^˜sú˝o{súo{súkZsú^˜F1Vµsúˇo{B9Œ)J1å%)RîJRNsJR˝NsRîRîJR Bˇ-kRîkZg9kZg9^˜kZsúZ÷Rî=ÔNskZkZ^˜˝c_^˜ccg9g9wΩg9^˜súo{kZsúwΩsúwΩc^˜cckZkZB-kVµo{g9Rî-kJRVµo{o{^˜JRΔBcNs)J=Ô5≠F1ckZg9Z÷RîF1BBNsVµ^˜ccsúkZsúwΩ{fiwΩˇo{Bc^˜VµNsZ÷^˜^˜cRîJRVµZ÷kZ9ŒJRVµRîRîJRRîB9Œ1å5≠1åB5≠F1%)9Œ9Œ5≠◊
)J)JF1F1-k• ÁΔJRRîJRVµc^˜˝Z÷8g9c^˜Z÷^˜Rî^˜ ÁwΩ^˜^˜Vµo{^˜RîJRZ÷g9^˜=ÔBRîcco{kZsúB^˜Z÷Z÷=Ô9ŒF1F15≠JR=ÔZ÷NsF1JRRîVµkZo{o{g9súo{RîF1JRJRF1F1JR˛NsRî! Á{fi=ÔNso{g9kZo{g9Z÷^˜JR=ÔRîo{˚c^˜o{˛kZ cc^˜cc^˜Ns9ŒBBF11å)JsúZ÷^˜^˜9Œ^˜cg9g9kZg9kZkZsúc9ŒsúkZ˛RîcVµVµZ÷c^˜c˝g9˛csúwΩ˛{fi)wΩsúckZZ÷o{co{kZZ÷VµVµNsRîNsNsZ÷g9cRîF1RîVµcB5≠9Œ5≠RîRî-k-k)J-k1å1å5≠F1F15≠1å1å≈Ñ•ΔÑΔΔ Á Á˛Δ•Δ¸•Δ•Δ Á Á˛!˝%) )J˙%))J%))J!)J˛%)˛)J%)5≠JRJRΔΔ•RîJRNsF1^˜^˜cVµcVµRîc^˜^˜Z÷Z÷RîZ÷)JkZ˛Vµ)^˜B9Œ5≠Rîg95≠F1Vµ^˜o{súo{cNsVµF1JR=Ô9Œ1å9ŒNs9Œ9Œ=ÔF15≠=ÔB^˜súo{súkZkZo{kZF1NsF1Ns˝JRNsVµ1å g9NsBsú^˜g9g9kZZ÷^˜JR=ÔNsg9g9c^˜˛cVµg9kZg9kZkZ^˜g9g9^˜g9VµRîF19ŒJRVµ)JVµc^˜g9Z÷5≠g9kZkZ˛g9o{wΩJR1åo{g9ckZ^˜^˜Z÷^˜Z÷cg9g9kZkZ˛g9ccsú{fi{fiwΩwΩ˛sú wΩkZo{g9súwΩcRîVµNs˛RîBB^˜kZBVµNsZ÷Z÷F15≠9Œ1åVµRî-k˛1å5≠-k9ŒB9Œ9Œ5≠F1Δ!BBÑ•! Á!˙ Á¸Δ••Ñ•˛Δ!!%)%))J¯%))J)J%)%))J˝%)=ÔRî5≠Δ cNsZ÷Z÷F1NsZ÷Z÷cZ÷^˜JRB˛cZ÷Z÷JRZ÷JRVµB^˜VµVµ=Ô9Œ=ÔNsJR)J1åkZ˛o{4súcNs=Ô5≠5≠1å9Œ5≠-kB1å1åNs1å5≠BNsg9kZo{o{g9kZsú^˜BNsNsF1F1JRNsNsRîNs )Jo{F1o{^˜g9g9kZccRîF1F1ckZg9˛^˜g9Nsc^˜cco{cg9˛c.Vµcg9g9cJRJR5≠{fikZsúsú9ŒRîg9Z÷Z÷o{kZo{{fig9=Ôcg9c^˜Vµ^˜Z÷^˜ccg9g9ckZckZc^˜cwΩ{fi{fiwΩwΩ˛sú(wΩsúo{o{wΩwΩ^˜NsZ÷VµVµRîRîJRNsF1F1^˜NsRîRîVµVµ1åB1å5≠F1Ns)J1å-k1å-k1å-kB5≠B1åJR–¸B •! Á! Á!! Á Á! Á!! Á!! ÁΔ ÁΔ ÁΔ•Δ Á!!%)%))J˝%))J%)!%))J)J˛%)%)J)JJRF1 ÁÑ9Œ^˜VµNsB^˜JR^˜c^˜c9ŒckZkZg9Vµ^˜BVµRîRîJRcZ÷BF15≠F1Ns=Ô=Ô˛o{Xsúsúc^˜cJR1å-k=Ô5≠1å1å-k-kF15≠1åF1BRîVµo{wΩsúcwΩ^˜1åJRNsJRF1JRNsNsRîRî5≠ Z÷RîkZ^˜ccsúcg9^˜VµRîsúwΩsúwΩ{fisúo{VµZ÷cc^˜kZ^˜cVµ^˜o{JRF1Rî^˜cVµc-k^˜{fiwΩwΩˇ!sú{fiZ÷5≠súsú˝kZ g9˝c^˜g9g9kZg9kZg9kZckZcco{ˇˇwΩsú˝wΩ ˇ˛wΩo{c˛Z÷˛Rî˛NsJRNsBJRg9Z÷JRZ÷Rî=Ô1å=Ô1åB5≠1å-k-k1å-k1åF1BF1=Ô1å=Ô’˝•Δ! Á!˝ Á! Á Á! Á! Á! Á%)!%)!%)%)!! ÁΔΔ•ΔΔ˛!¸%)$)J%)%))J%)!5≠Ns9ŒΔΔRî^˜RîVµ=ÔVµ9Œ^˜^˜cZ÷ccg9g9^˜Z÷^˜BNsRîcJRVµVµF1˛BCZ÷1å^˜súkZkZsúg9VµJRJR9Œ5≠-k-k1åB1å5≠1å9Œ1åF15≠BF1RîJRNsZ÷g9B Á9ŒRîF1BF1NsJRRîNsRî c cZ÷9ŒkZcckZc^˜Z÷F1F1kZ{fio{o{kZ^˜g9^˜RîJR=Ô=Ô˛^˜NsckZ^˜F1JRJRNs^˜cRî9ŒkZwΩsúˇRîF1kZˇ^˜Vµo{g9Vµg9˛c^˜Z÷^˜Z÷˛g9cg9c˛g9#cg9sú{fisúwΩwΩˇwΩwΩg9súg9g9kZcVµVµRîVµRîZ÷RîRîNsNsBJRBJR=ÔJR^˜VµZ÷F1˛1å5≠5≠1å-k˛1å-k5≠=ÔB5≠9ŒNs=ÔŒ
•Ñ•• Á Á!! Á Á!˛ Á! Á! Á˛! Á˝!¸%) !! Á!Δ ÁΔ Á Á!%))J˛%)2)J%))JF1JR%)•1åkZZ÷cZ÷Ns9ŒVµRîZ÷^˜Z÷Z÷ckZc^˜cZ÷JR=ÔVµ^˜BRîRîBF1NsZ÷^˜JR-kkZwΩcVµVµNsB=Ô5≠5≠9Œ˝-k!=Ô1å=Ô1å5≠=ÔF1F1VµZ÷c9Œ9Œ1åRîJRF1JRJRNs˛Rî<5≠!!NsF1o{^˜cg9g9o{F19ŒVµo{kZZ÷Z÷^˜kZo{F1-k=ÔNso{cRîNsZ÷^˜Z÷ccJRB=ÔJRRîRî5≠{fisúwΩwΩRîVµwΩsúkZg9^˜ckZcg9c^˜^˜c^˜˝g9kZg9g9cc˝g9^˜g9ckZkZg9c^˜^˜˛Z÷^˜^˜Z÷˛Vµ Rî˛NsJRJRNsNs=Ô=Ô9ŒRî^˜Z÷B5≠9Œ5≠5≠1å5≠˛1å)J5≠9Œ-kJR9Œ=ÔNs5≠Ÿ ••Ñ•Δ! Á Á!! Á!!¸ Á Δ˛! Á%)!˛%)!%)!)J!%)!˛%)7 Á!ΔΔ Á!!)J!!5≠Ns=Ô Á cg9VµZ÷cZ÷F1BRîVµRî^˜Rîg9cc^˜cZ÷VµRî9ŒRîRî9ŒRîF1VµVµRî^˜^˜Ns1å=ÔNsZ÷g9Z÷RîF1B˛5≠
)JΔ! c-k)J9Œ1å9Œ9ŒF1˛RîAcBZ÷súBJRJRF1F1NsNsJRRîRî Á Z÷RîRîZ÷Rîcg9Z÷Z÷=ÔF1cg9g9súsúwΩo{{fisúF1RîVµ^˜Z÷Z÷^˜cg9Nscc^˜RîVµ=ÔF19ŒNso{o{wΩkZBZ÷wΩsúZ÷g9kZ˛c
